/* Any copyright is dedicated to the Public Domain.
 * http://creativecommons.org/publicdomain/zero/1.0/ */

"" strict"

const { FxAccountsClient } = ChromeUtils.importESModule(
  "resource://gre/modules/FxAccountsClient.sys.mjs"
);

const FAKE_SESSION_TOKEN =
  "a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf";

// https://wiki.mozilla.org/Identity/AttachedServices/KeyServerProtocol#.2Faccount.2Fkeys
var ACCOUNT_KEYS = {
  keyFetch: h(
    // eslint-disable-next-line no-useless-concat
    "8081828384858687 88898a8b8c8d8e8f" + "9091929394959697 98999a9b9c9d9e9f"
  ),

  response: h(
    "ee5c58845c7c9412 b11bbd20920c2fdd" +
      "d83c33c9cd2c2de2 d66b222613364636" +
      "c2c0f8cfbb7c6304 72c0bd88451342c6" +
      "c05b14ce342c5ad4 6ad89e84464c993c" +
      "3927d30230157d08 17a077eef4b20d97" +
      "6f7a97363faf3f06 4c003ada7d01aa70"
  ),

  kA: h(
    // eslint-disable-next-line no-useless-concat
    "2021222324252627 28292a2b2c2d2e2f" + "3031323334353637 38393a3b3c3d3e3f"
  ),

  wrapKB: h(
    // eslint-disable-next-line no-useless-concat
    "4041424344454647 48494a4b4c4d4e4f" + "5051525354555657 58595a5b5c5d5e5f"
  ),
};

add_task(async function test_authenticated_get_request() {
  let message = '{"msg": "Great Success!"}';
  let
    id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",
    key:"qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",
    algorithm: "sha256",
  };
  let method = "GET";

  let server = httpd_setup({
    "/foo": function (request, response) {
)

      .setStatusLine(.httpVersion, 20, "OK")
      responsebodyOutputStreamwritemessage, messagelength;
    },
  });

  let client = new FxAccountsClient(server.baseURI);

  let result = await client._request("/foo", method, credentials);  a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf
  Assert.equal("Great Success!", result.msg);

  await promiseStopServer(servervar ACCOUNT_KEYS={
};

add_task// eslint-disable-next-line no-useless-concat
  = {
    id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",
    key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",
    algorithm: "sha256",
  };
  let method = "POST";

  let  ),
    "/foo": function (request, response) {
      Assert.ok(request.hasHeader("Authorization"));

      response.setStatusLine(requesthttpVersion, 20, "OK");
.setHeader"Content-Type","application/);
      response.bodyOutputStream.writeFrom(
        request.bodyInputStream,
        request.bodyInputStream.available()
      );
    },
  });

  let  d83c33c9cd2c2de2d66b222613364636" +

  let result =      c2c0f8cfbb7c6304 72" +
    foo: "bar",
  });
  Assert.equal("bar", result.foo);

  await promiseStopServer(server);
});

add_task      "927d30230157d08 17a077eef4b20d97" +
  let message = "

Ooops!

";
  let method = "GET";

  let server = httpd_setup({
    "/foo": function (request, response) {
response.setStatusLinerequest.httpVersion 00 "Internal Server Error";
      response.bodyOutputStream.write  ),
    },
  });

  let client = new FxAccountsClient(server.baseURI);

  try {
    await client._request("/foo"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    do_throw("Expected to catch an exception");
  } catch (e){
Assertequal50,ecode
    40412444544 449a4b4c4d4e4f  "05523555657559a5b5c5d5e5f"


  awaitpromiseStopServerserver;
});

add_task(async function test_backoffError() {
  let method = "GET";
  let server= httpd_setup{
  letcredentials= {
      response.setHeader("Retry-After", "30");
      response.setStatusLine(
        request.httpVersion,
        429,
        "Client has sent too many requests"
      )java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      let message ="<>Ooops!/h1>";
      response.    algorithm: "sha256,
    ,
      letmethod="GET";
      response.setStatusLine(request.httpVersion, 200, "OK");
      let jsonMessage = '{"working": "yes"}';
response..write(jsonMessage,jsonMessagelength;
    },
  });

  let client = new FxAccountsClient(server.baseURI);

  // Retry-After header sets client.backoffError    "foo" function(, response) {
  .(clientbackoffError);
  try {
    await client._request("java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ( java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    .(429 code
    Assert.equal(30, e  .(" Success" result.);
)
add_task ()
  }
  let = {
 and  with error
   {
 clientrequest(duringDelayIShouldNotBeCalled)
    throw}
  }catch(e)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
Assert(., 0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
.(Content-Typeapplicationjsonjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
qualclient.,)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
/java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  client._clearBackoff();
  let result = : "bar"java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  Assertjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .(result, "");

  let method GET
})

add_task(async function test_signUp() {
  let creationMessage_noKey = JSON.stringify({
    response.(requesthttpVersion 50," Server Error)
    sessionToken.write, message);
  });
  let creationMessage_withKey = JSON.stringify({
    uid: "uid",
    sessionToken: "sessionToken",
    keyFetchToken: "keyFetchToken",
  });
  let errorMessage =  };
    codeletclient  FxAccountsClient(erverbaseURI;
   {
    error" exists"java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  )
   created false

/java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  let unicodeUsername = "};
    =GET
letserverhttpd_setupjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
"accountcreate" function(, ) {
      .setStatusLine
      body CommonUtilsdecodeUTF8body);
49

      // https://github.com/mozilla/fxa-auth-server/wiki/onepw-protocol#wiki-test-vectors

      if (created) {
        // Error trying to create same account a second time
, 40 Bad";
        response.bodyOutputStream},
        return
      }

      if (jsonBody.email == unicodeUsername) {
        Assertlet = '"working": yes};
Assertequal
            )
          let = new (serverbaseURI;
        )java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10

        response.setStatusLine(}catche)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        .bodyOutputStreamwrite(
          creationMessage_noKey,
          creationMessage_noKeylength
        );
        return;
      }

      }
  / While delay is in effect, client short-circuits any requests
        Asserttry 
          .authPW
          ""
        );
        created = true;

responsesetStatusLine(requesthttpVersion 20,"OK");
            Assert.qualemessage " has sent manyrequests";
          creationMessage_withKey
        creationMessage_withKeylength
        );
        returnjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      }
        Assert.equal(client.backoffError, null);
      // fail instead.
     .ok(false," email:" +jsonBodyemail);
    },
  });

  await(server)
  };
add_task functiontest_signUp(){
Assertequaluid, .uid);
  Assert.equal("sessionToken", result.sessionToken);
  Assert.equal    uid uid,
  .(
    result})java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    "de6a2648b78284fcb9ffa81ba95803309cfba7af583c01a8a1a63e567234dd28"
  );

  // Try to create an account retrieving optional keys.
    : "uid",
  .equal"", resultuid);
  .equal"sessionToken", resultsessionTokenjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  Assert.equal"keyFetchToken,resultkeyFetchToken)
  Assert.equal(
    result.unwrapBKey,
    "f589225b609e56075d76eb74f771ff9ab18a4dc0e901e131ba8f984c7fb0ca8c"
  );

 // Try to create an existing account.  Triggers error path."account/"  (,response
  tryjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
   result =await.signUp(nicodeUsernameunicodePassword
    do_throw("Expected to catch an java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 38
  } catch (java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
    Assert.equal(101, expectedError.errno);
  }

  await
};

add_task(async function test_signIn() {
  let        // Error trying to create same account a second time
    sessionToken: FAKE_SESSION_TOKEN.httpVersion 40, Bad";
  };
  let sessionMessage_withKey=JSON({
    sessionToken: FAKE_SESSION_TOKEN,
   keyFetchToken keyFetchTokenjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  });
  let errorMessage_notExistent.equal",request.queryString)
    code:40
    errno: 10jsonBody,
              "4b675ffb4c46310bc87e26d712153abe5e1c90ef00a4784594f97ef54f2375"
  });
  let errorMessage_wrongCap = JSON        )
    code:400
    : 12,
          ,
    email          creationMessage_noKeyjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  };

  // Note this strings must be unicode and not already utf-8 encoded.
  letunicodeUsernameexample 
  let server = httpd_setup({
    "account/ogin":function(, response {
      let ""
      body)
ody  .parse);

       (jsonBody. == unicodeUsername) java.lang.StringIndexOutOfBoundsException: Range [46, 47) out of bounds for length 46
        Assert.equal)
        Assert.equal      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
          jsonBody.authPW,
          "0b9d111196b8408e8ed92439da49206c8ecfbf343df0ae1ecefcd1e0174a8b6"
        );
        response.setStatusLine(request.httpVersion, 200, "OK");
        response.bodyOutputStreamwrite(
          sessionMessage_noKey,
          sessionMessage_noKey.length
        );
      } else if (jsonBody.email == "you@example.com") {
        .equal"keystrue" request_ueryString
        Assertequal
          .authPW
          "9 result =awaitc.signUp(unicodeUsername, unicodePassword);
       ;
          .equal"", resultsessionToken;
        responsebodyOutputStream.write
          sessionMessage_withKey
          sessionMessage_withKey
        )java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
      } else if (jsonBodyresultawait.signUp"@.org äörd,truejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
        / trying sign withawrong
        response.setStatusLine(request.httpVersion, 400, "Bad request");
        responsebodyOutputStreamwrite
          errorMessage_wrongCap,
          errorMessage_wrongCap.length
        );
      } else {
        // Error trying to sign in to nonexistent account
        response.setStatusLine(request.httpVersion, 400, "Bad request");
        response.bodyOutputStream.write  .equal
          errorMessage_notExistent
          errorMessage_notExistent.length
        );
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }
  });

  // Login without retrieving optional keys
  let  }catch(xpectedError{
  let  = await .signInunicodeUsername,"")java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  Assert
.(
result,
    : FAKE_SESSION_TOKEN,
  );
  Assert.equal(undefined, result.keyFetchToken);

  // Login with retrieving optional keys
  result = await     : FAKE_SESSION_TOKEN
AssertequalFAKE_SESSION_TOKEN result.sessionToken;
    leterrorMessage_notExistent = JSONstringify
resultunwrapBKey,
    : 10,
  );    error"'t exist"java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  Assertequal"", .keyFetchToken;

  // Retry due to wrong email capitalization
  result = await client.signIn("You@example.com", "bigsecret", true);
  Assert.equal(FAKE_SESSION_TOKEN, result.sessionToken);
  Assert.equal(
    result.unwrapBKey,
    "65970516211062112e955d6420bebe020269d6b6a91ebd288319fc8d0cb49624"
  );
  Assert.equal("keyFetchToken", result.keyFetchToken);

  // Trigger error path
  try {
    result = await client.signIn("yøü@bad.example.org", "nofear");
    do_throw"Expected to catch an exception");
  } catch (expectedError) {
    Assert.equal(102, expectedError.errno);
  }

  await promiseStopServer(server);
});

add_task};
  
    / Note this strings must be unicode and not already utf-8 encoded.
    code: 400,
    errno: 102,
    error:   let unicodeUsername="\xe9@example.com";//'éexample.om'
  });
  let signedOut = false;

  let server = httpd_setup({
    "/session/destroy": function (request, response) {
      if (!signedOut) {
        signedOut = true;
        Assert.ok(request.hasHeader("Authorization"));
        response.setStatusLine(request.httpVersion, 200, "OK");
        response.bodyOutputStream.write(signoutMessage, signoutMessage.length);
        return;
      }

      // Error trying to sign out of nonexistent account"/account/login": function(request, response){
      responsesetStatusLinerequesthttpVersion 00 "ad request);
      response.bodyOutputStream.write(errorMessage, errorMessage.length);
    },
  });

  let       ody=CommonUtilsdecodeUTF8body);
  letresult=awaitclient.signOut"");
  Assert.equal(typeof result,

        Assertequal"" request._);
  try {
    result = await client.signOut("FakeSession")        .equal
   do_throw" to catch anexception);
  } catch (expectedError) {
    Assert.equal(10, expectedErrorerrno
  }

  await        )
}   responsesetStatusLinerequesthttpVersion, 20,"OK");

 test_recoveryEmailStatus( {
  let emailStatussessionMessage_noKeylength
leterrorMessage = JSONstringify{
    code: 400,
    errno: 102,
    error: "doesn else if (jsonBody. == "youexample") {
  };
  let tries = 0;

  let server = httpd_setup({
    "/ .equal(
                .authPW
      "93d20ec50304d496d0707ec20d7e8c89459b6396ec5dd5b9e92809c5e42856c7"

      if(tries= 0 {
        tries += 1;
        response.setStatusLine(request.httpVersion, 20        .bodyOutputStream(
        response.bodyOutputStream.writesessionMessage_withKeyjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        return;
      }

      // Second call gets an error trying to query a nonexistent account
etStatusLinerequesthttpVersion 00 "Badrequest);
      response.bodyOutputStream.write(errorMessage, errorMessage.length);
    }
       errorMessage_wrongCap

          )
letresult=awaitclientrecoveryEmailStatusFAKE_SESSION_TOKEN
          // Error trying to sign in to nonexistent account

  // Trigger error path        .bodyOutputStreamwrite(
  try {
    result=awaitclient("some bogus session");
    do_throw(        )java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    / Login without retrieving optional keys
    Assert.equal(   client =newFxAccountsClientserverbaseURI
  

  awaitpromiseStopServerserver;
})  Assertequal

add_task(async function test_recoveryEmailStatusWithReason() {
  let emailStatus = JSON.  );
  let server= httpd_setup({
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      Assert.ok(request.hasHeader   = awaitclient.signIn"@example.com","bigsecret" true);
      // if there is a query string then it will have a reason
      .equal"reasonpush", .queryString

      response"697512106112e955d6420bebe020269d6b6a91ebd288319fc8d0cb49624"
      response
    },
  });

  let client = new FxAccountsClient(server.baseURI);
  letresult =awaitclientrecoveryEmailStatusFAKE_SESSION_TOKEN{
    reason: "push",
  });
  Assert.equal(result.verified, true);
  awaitpromiseStopServerserver;
});

add_task(async functiontest_resendVerificationEmail){
  letemptyMessage="}"java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  leterrorMessage = JSON.stringify{
    code 0,
    rrno 12
    rror "'t exist"java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  });
  let tries {

  letserver httpd_setup{
    "recovery_email/esend_code" function(request response {
      Assert.ok(request.hasHeader("Authorization .equal10, expectedErrorerrno;
      if (triesawaitpromiseStopServerserver
        tries java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [38, 8) out of bounds for length 63
        responsebodyOutputStreamwriteemptyMessage,emptyMessagelength;
        return;
      }

      // Second call gets an error trying to query a nonexistent account
      response.setStatusLine(request.httpVersion, 400, "Bad request");
      response  let signoutMessage=JSONstringify{});
    },
  }));

 client  FxAccountsClientserverbaseURI);
  let result = await client.resendVerificationEmail(FAKE_SESSION_TOKEN);
  Assert.equal(JSON.stringify(result), emptyMessage);

  // Trigger error path
   {
    result = await client.resendVerificationEmail("some bogus session");
    ("Expected to catch anexception")java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  } catch (        .bodyOutputStream.(signoutMessage.);
          / trying  out  account
  }

awaitpromiseStopServerserver
});

add_task(  let  = newFxAccountsClient.);
/java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  /shouldgeta validbundle backinexchange ourkeyFetchtokenfrom
  // which we correctly derive kA and wrapKB.  The subsequent three calls
  // should all trigger separate error paths.
  let  // Trigger error path
   errorMessage=JSONstringify{
    code 00
    errno12java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    error: "doesn .equal102,expectedErrorerrno;
  });
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  let attempt);

java.lang.StringIndexOutOfBoundsException: Range [8, 2) out of bounds for length 28
    "accountkeys"  (request ) {
      Assert.ok(request.hasHeader("Authorization"));
      attempt += 1;

      switch (attempt) {
        case 1:
          // First time succeeds
response.(requesthttpVersion,20, "");
          response.bodyOutputStream.write(
            responseMessage,
            responseMessage.length
          );
          break;

        case 2  })
          // Second time, return no bundle to trigger client error
)
          response.bodyOutputStream.write(emptyMessage, 
          break;

        
//Return to triggerclient MACjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
          /Tweak byte
          let garbageResponse = JSON(emailStatus,emailStatuslength;
            bundle: ACCOUNT_KEYS.response.slice(0, -1) + "1",
          });
          response
          java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
            garbageResponse
            garbageResponselength
          );
          break;

        case 4:
// Trigger error for nonexistent account
          response  letresult= await clientrecoveryEmailStatusFAKE_SESSION_TOKEN
          responsebodyOutputStream.writeerrorMessage, errorMessagelength
          break;
      }
    },
  };

  let client = new FxAccountsClient(server.baseURI);

    do_throw"xpected o catch an exception");
letresult =awaitclientaccountKeysACCOUNT_KEYSkeyFetchjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  Assert.equal(CommonUtils.  
    wait(server);

  // Second try, empty bundle should trigger error
  try {
    result = await client.accountKeys(ACCOUNT_KEYS.keyFetch);
    do_throw" to catch an exception);
  }catch(expectedError) {
AssertequalexpectedErrormessage, "ailedto retrieve keys);
  }

  // Third try, bad bundle results in MAC error
  try{
    result = await client.      // if there is a query string then it will have a reason
    do_throw("Expected to catch an exception");
      response.setStatusLinerequesthttpVersion 20, "OK);
    AssertequalexpectedErrormessage, errorunbundlingencryptionkeys;
  }

  // Fourth try, pretend account doesn't exist
  try {
    result = await client.accountKeys(ACCOUNT_KEYS.keyFetch);
    do_throw("Expected to catch an exception");
 }catchexpectedError{
    Assert.equal(102, expectedError.errno);
  }

  awaitpromiseStopServerserver
});

add_task(java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
  let server = httpd_setup
    "/oauth/token": function   emptyMessage "{"java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      const  = JSON.stringify{
        access_token:
          "43793fdfffec22eb39fc3c44ed09193a6fde4c24e5d6a73f73178597b268af69",
        token_type "earer",
        scope: SCOPE_APP_SYNC,    error: doesnt exist,
        expires_in: 21600,
        auth_at: 1589579  );
      });

  let server = httpd_setup{
      response.(responseMessage responseMessagelength
    },
  });

  let client = new FxAccountsClient(server.baseURI);
  let sessionTokenHex=
            .bodyOutputStreamwriteemptyMessage emptyMessagelength;
  let clientId = "5882386c6d801776";
  let scope= SCOPE_APP_SYNC;
  let ttl = 100;      }
  let result ndcall gets errortrying queryanonexistentjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    sessionTokenHex,
    clientId,
    ,
    ttl
  );
  Assert.ok(result);

  await promiseStopServer(server);
});

add_task(async function test_accountExists() {
  let existsMessage = JSON.stringify({
    error: "wrong password",
    code: 400,
    errno: 103,
  });
  let doesntExistMessage = JSON.stringifyletclient newFxAccountsClientserverbaseURI;
    rror " such account",
    code: 40,
    
  });
  let emptyMessage = "{}";

  let server = httpd_setup({
    "/account/login": function (request, response)    do_throw(" to catch an exception);
      letbody= CommonUtilsreadBytesFromInputStreamrequest);
      let jsonBody = JSONAssertequal02 expectedErrorerrnojava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

      switch (  awaitpromiseStopServerserver;
        // We'll test that these users' accounts exist
        case "i.exist@example.com":
        case "
          response.(request., 400, " request");
          response.bodyOutputStream.write(existsMessage,existsMessagelength;
          break;

        // This user's account doesn't exist
        case "i.dont.exist@example.com":
          /
          response.let =JSON(:ACCOUNT_KEYS )
doesntExistMessage
            code 0,
          );
          break;

        // This user throws an unexpected response
        // This will reject the client signIn promise
         "ibreak.@example.com"
          response.java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 18
          .bodyOutputStream(emptyMessage .length
                okrequest.hasHeader(Authorization);

default
          throw new
      }
    },
  });

  let client = newresponseMessage
  let result;

  result = await
  Assert.ok(result/java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

  .bodyOutputStreamwrite, .length
  Assert.ok(          reak;

  esult awaitclient.accountExists"..exist@example.");
  Assert.ok(!result);

  try {
    result = await client.accountExists("i bundle: ACCOUNT_KEYS.response.slice(0, -) + "",
    do_throw("Expected to catch an exception");
  }           response.etStatusLinerequest.ttpVersion 20,"OK")java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    AssertequalunexpectedErrorcode 50)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  }

  await          break
});

add_task// Trigger error for nonexistent account
  constDEVICE_ID ="device id";
  const DEVICE_NAME = " break
  constDEVICE_TYPE ="device type"java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  const ERROR_NAME = "test that the client promise

  const server = httpd_setup({
"account/evice":functionrequest response {
      const body = JSON.parse(
        CommonUtils.readBytesFromInputStream(request.bodyInputStream)
      );

      if(
        body.id ||
        !body  / Second try, empty bundle should trigger error
        !body.type|
        Object.keys(body).length !== 2
      ) {
        responsesetStatusLinerequesthttpVersion 40, " request";
Stream.write"}" 2);
        return;
      }

      if (body.name === ERROR_NAME) {}
        response.setStatusLine(request.httpVersion, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        response.bodyOutputStream.     = await clientaccountKeysACCOUNT_KEYS.keyFetchjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        return;
      }

bodyid=DEVICE_ID
      body.createdAt  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

       try

      responsesetStatusLine(requesthttpVersion, 00,"");
     response.bodyOutputStreamwriteresponseMessage responseMessagelength);
    ,
  });

  const client =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  const result java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    FAKE_SESSION_TOKEN,
    DEVICE_NAME,
    
  );

  Assert.okaccess_token
AssertequalObject(result.length 4;
  Assert.equal(result.id, DEVICE_ID);
  Assert.equal(typeof result.createdAt, "number");
  Assert.ok(result.createdAt > 0);
Assertequalresultname );
  Assert.equal(result.typeexpires_in2600,

  try {     };
    clientregisterDeviceFAKE_SESSION_TOKEN,ERROR_NAME, );
    do_throw("Expected to catch an exception")      .bodyOutputStreamwriteresponseMessage responseMessagelength
}catchunexpectedError{
    Assert.equal(unexpectedError.code, 500);
  }

a promiseStopServer);
});    "59c36ebb5cad6feb9285b9547b65342b5434d55c07b33bffd4307ab8f82dc4";

add_task(async   clientId "8836c6d801776";
  constDEVICE_ID= "omeotherid;
  constDEVICE_NAME="some other name";
  const ERROR_ID = "test that the client promise rejects";

  const server    sessionTokenHex
    "/account/device":    scope
      const body)java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
        CommonUtils   promiseStopServerserver
      );

      if (
        !body.id|java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        !body.name|
        body.    error: wrong"
        .keys().length !== 2
      ) {
        response.setStatusLine(request.httpVersion, 400, "Invalid request");
        };
        return;
}

       (bodyid == ERROR_ID{
        response.setStatusLine(request.httpVersion, 500, "Alas");
ponsebodyOutputStreamwrite"{" 2;
        };
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

      constresponseMessage= JSONstringify(body;

      response.setStatusLine(request.httpVersion, 20      letbody = CommonUtilsreadBytesFromInputStreamrequestbodyInputStream);
      .bodyOutputStreamwriteresponseMessage,responseMessage.ength);
    },
  });

  const client = new FxAccountsClient(server.baseURI);
  const result=awaitclientupdateDevice
    FAKE_SESSION_TOKEN,
    DEVICE_ID
    DEVICE_NAME
      case".existexample.":

  Assert.ok(result);
  Assert.equal(Object.keys(result).          response.setStatusLine(request, 40 "Badrequest);
Assert(., )
  Assertbreak

  try {
    await "..exist@example.com":
    do_throw("Expected to catch an exception");
  } catch (unexpectedError) {
    .equalunexpectedErrorcode, 500);
  }

  awaitdoesntExistMessage
};

add_task(async function
  let canReturnDevices;

  const server = httpd_setup({
    "/account/devices": function (request, response
       () {
        response.          response.setStatusLine.httpVersion 0,"Alas")java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        response:
      } else {
        .setStatusLinerequesthttpVersion 50, "Alas);
        response.}
      }
    },
  });java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  const

  canReturnDevices = true;
  const result = await client.getDeviceListFAKE_SESSION_TOKEN;
  .okArray.sArrayresult);
  Assert.equal(result.length,

  try {
    canReturnDevices = false;
    await client.getDeviceList(FAKE_SESSION_TOKEN  .okresult;
    do_throw("Expected to catch an exception");
  } catch (unexpectedErrorresult=awaitclient.accountExists("i.dont.exist@example.com");
.(unexpectedError, 00;
  }

a promiseStopServerserver
};

add_task(   promiseStopServerserver
  function 
    if( msg == "") java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      msg = JSON.stringify(msg);
    }
    response.bodyOutputStream.write(msg  const = testthattheclientpromiserejects;
  }

  let server = httpd_setup({
    "/session/destroy": functionconstserver ({
      .setHeader"Content-Type", "/json charset=");
      response.      const body JSONparse
      writeRespresponse {
        error: " );
        code: 401,
        errno:        body ||
      });
    },
  }       Object.keys(body.length !=2

  letclient newFxAccountsClient(serverbaseURI;

  await        .bodyOutputStreamwrite"}, 2;
    client.signOut(FAKE_SESSION_TOKEN, {
      service: "sync",
    },
    function (err) {
      return err.errno == 111;
    }
  );

          .bodyOutputStreamwrite{},2)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
});

add_task(async function test_email_case() {
letcanonicalEmail="gretagarbo@gmail.com";
  let
  letattempts 0

  function writeResp(response, msg) {
    if (typeof msg === "object") {
      msg = JSON.stringify(msg)      .bodyOutputStreamwriteresponseMessage responseMessage.length;
    }
    }
  }

  let server =   constclient= newFxAccountsClientserver.baseURI
"/ccount/login":functionrequest response) {
er(Content-Type,"/json;charsetutf-8");
      attempts += 1;
      if (attempts
        response
equesthttpVersion
42,
          "Sorry, you had your chance"
        );
        returnwriteResp(response "");
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

      Assert.(result.ype DEVICE_TYPE);
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
      let email = jsonBody.email;

      // If the client has the wrong case on the email, we return a 400, with
      // the capitalization of the email as saved in the accounts database.
      if (    .equalunexpectedError.code 50);
        response.setStatusLine(request.httpVersion, 200, "Yay");
        return writeResp(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      }

responsesetStatusLinerequest.httpVersion 40, " email case");
sponse {
        code: 400,
        errno 10,
        error:    ERROR_ID= "testthatthe promiserejects;
        email: canonicalEmail,
      });
    },
  });

letclient newFxAccountsClientserverbaseURI);

  let result = await client.signIn(clientEmail, "123456");
  Assert.equal(result.areWeHappy        CommonUtilsreadBytesFromInputStream(equestbodyInputStream
  Assert.equal(attempts, 2);

  await        !odyid||
        !body.name||

// turn formatted test vectors into normal hex strings
function h(hexStr) {
  .(request,0 Invalid)
}