insertOp2.execute(docA)

    insertOp1.execute(docB)

    t.is(docA.str, docB.str, "docA.str = docB.str")
    t.is(docA.digest(), docB.digest(), "docA.digest() = docB.digest()")
})

test.failing("commutative-insert-deletion", (t) => {
    const replicaNumberA = 1
    const docA = new LogootSRopes(replicaNumberA)
    const replicaNumberB = 2
    const docB = new LogootSRopes(replicaNumberB)

    const insertOp = docA.insertLocal(0, "hello world")
    const deleteOp = docA.delLocal(5, 5 + " world".length)

    deleteOp.execute(docB)
    insertOp.execute(docB)

    t.is(docA.str, docB.str, "docA.str = docB.str")
    t.is(docA.digest(), docB.digest(), "docA.digest() = docB.digest()")
})

test("commutative-insert-split", (t) => {
    const replicaNumberA = 1
    const docA = new LogootSRopes(replicaNumberA)
    const replicaNumberB = 2
    const docB = new LogootSRopes(replicaNumberB)

    const insertOp = docA.insertLocal(0, "hello world")

      attributes: loginCredentials
    }
  });
  await app.post('/users/auth/login', loginCredentials);

  let db = app.lookup('orm-adapter:memory')._cache;
  t.truthy(db.user[1].lastLoginAt);
  t.truthy(db.user[1].lastIp);
  t.is(db.user[1].loginCount, 1);
});

test.failing('tracks last seen time', async (t) => {
  let app = new AppAcceptanceTest();
  let loginCredentials = {
    email: '[email protected]',
    password: '123'
  };
  await app.post('/users/auth/register', {
    data: {
      type: 'user',
      attributes: loginCredentials
    }
  });
  let { body } = await app.post('/users/auth/login', loginCredentials);
  app.setHeader('Authorization', `TOKEN ${ body.token }`);
  await app.get('/');

  let db = app.lookup('orm-adapter:memory')._cache;
  t.truthy(db.user[1].lastSeen);
});

		options: {baseUrl: 'https://example.com'},
		handler: options => {
			options.baseUrl = 'https://google.com';
		}
	});

	await t.throwsAsync(instanceA('/'), 'Failed to set baseUrl. Options are normalized already.');
});

// TODO: fix this
test.failing('throws if the `searchParams` key is invalid', async t => {
	await t.throwsAsync(got('https://example.com', {
		searchParams: {
			// @ts-ignore
			[undefined]: 'valid'
		}
	}), {
		instanceOf: TypeError,
		message: 'The `searchParams` key \'\' must be a string, number, boolean or null'
	});
});

test('throws if the `searchParams` value is invalid', async t => {
	await t.throwsAsync(got('https://example.com', {
		searchParams: {
			foo: []
		}
	}), {
		instanceOf: TypeError,
		message: 'The `searchParams` value \'\' must be a string, number, boolean or null'
	});

test.failing("non-convergent-balanced-trees-different-digests", (t) => {
    const docs: LogootSRopes[] = []

    const files = [
        "trees/trees-nct/tree-nct-nikita-button-shirt-1.json",
        "trees/trees-nct/tree-nct-nikita-button-shirt-2.json",
    ]

    files.forEach((file) => {
        const data = fs.readFileSync(file, "utf8")
        const tree = JSON.parse(data)

        const doc: LogootSRopes | null = getLogootSRopesFromTree(file)

        if (doc !== null) {
            docs.push(doc)
        } else {
            t.fail("the file must contains a valid serialization of a LogootSRopes")
        }
    })

    const digests: number [] = docs.map((doc: LogootSRopes) => doc.digest())
    const allDifferents: boolean = digests.every((digest, index) => {
        return digests.every((otherDigest, otherIndex) => {
            return index === otherIndex || digest !== otherDigest
        })
    })

    t.true(allDifferents)
})