public async Task TestApiKey()
{
var addOne = await _index1.SaveObjectAsync(new SecuredApiKeyStub { ObjectID = "one" });
var addTwo = await _index2.SaveObjectAsync(new SecuredApiKeyStub { ObjectID = "one" });
addOne.Wait();
addTwo.Wait();
SecuredApiKeyRestriction restriction = new SecuredApiKeyRestriction
{
ValidUntil = DateTime.UtcNow.AddMinutes(10).ToUnixTimeSeconds(),
RestrictIndices = new List <string> {
_index1Name
}
};
string key = BaseTest.SearchClient.GenerateSecuredApiKeys(TestHelper.SearchKey1, restriction);
SearchClient clientWithRestriciton = new SearchClient(TestHelper.ApplicationId1, key);
SearchIndex index1WithoutRestriction = clientWithRestriciton.InitIndex(_index1Name);
SearchIndex index2WithRestriction = clientWithRestriciton.InitIndex(_index2Name);
await index1WithoutRestriction.SearchAsync <SecuredApiKeyStub>(new Query());
AlgoliaApiException ex = Assert.ThrowsAsync <AlgoliaApiException>(() =>
index2WithRestriction.SearchAsync <SecuredApiKeyStub>(new Query()));
Assert.That(ex.Message.Contains("Index not allowed with this API key"));
Assert.That(ex.HttpErrorCode == 403);
}
public async Task SynonymsOperationsTest()
{
BatchIndexingResponse addObjectResponse =
await _index.SaveObjectsAsync(_objectsToSave, autoGenerateObjectId : true);
addObjectResponse.Wait();
Synonym gba = new Synonym
{
ObjectID = "gba",
Type = SynonymType.Synonym,
Synonyms = new List <string> {
"gba", "gameboy advance", "game boy advance"
}
};
var regularSynonymResponse = await _index.SaveSynonymAsync(gba);
Synonym wiiToWiiu = new Synonym
{
ObjectID = "wii_to_wii_u",
Type = SynonymType.OneWaySynonym,
Input = "wii",
Synonyms = new List <string> {
"wii u"
}
};
Synonym playstationPlaceholder = new Synonym
{
ObjectID = "playstation_version_placeholder",
Type = SynonymType.Placeholder,
Placeholder = "<PLAYSTATIONVERSION>",
Replacements = new List <string>
{
"1",
"One",
"2",
"3",
"4",
"4 Pro"
}
};
Synonym ps4 = new Synonym
{
ObjectID = "ps4",
Type = SynonymType.AltCorrection1,
Word = "ps4",
Corrections = new List <string> {
"playstation4"
}
};
Synonym psone = new Synonym
{
ObjectID = "psone",
Type = SynonymType.AltCorrection2,
Word = "psone",
Corrections = new List <string> {
"playstationone"
}
};
List <Synonym> synonyms = new List <Synonym> {
wiiToWiiu, playstationPlaceholder, ps4, psone
};
var saveSynonymsResponse = await _index.SaveSynonymsAsync(synonyms);
regularSynonymResponse.Wait();
saveSynonymsResponse.Wait();
// Retrieve the 5 added synonyms with getSynonym and check they are correctly retrieved
var gbaTask = _index.GetSynonymAsync("gba");
var wiiTask = _index.GetSynonymAsync("wii_to_wii_u");
var playstationPlaceholderTask = _index.GetSynonymAsync("playstation_version_placeholder");
var ps4Task = _index.GetSynonymAsync("ps4");
var psoneTask = _index.GetSynonymAsync("psone");
Synonym[] tasks = await Task.WhenAll(gbaTask, wiiTask, playstationPlaceholderTask, ps4Task, psoneTask);
Assert.True(TestHelper.AreObjectsEqual(gba, tasks[0]));
Assert.True(TestHelper.AreObjectsEqual(wiiToWiiu, tasks[1]));
Assert.True(TestHelper.AreObjectsEqual(playstationPlaceholder, tasks[2]));
Assert.True(TestHelper.AreObjectsEqual(ps4, tasks[3]));
Assert.True(TestHelper.AreObjectsEqual(psone, tasks[4]));
// Perform a synonym search using searchSynonyms with an empty query, page 0 and hitsPerPage set to 10 and check that the returned synonyms are the same as the 5 originally saved
SearchResponse <Synonym> searchResponse =
await _index.SearchSynonymsAsync(new SynonymQuery { HitsPerPage = 10, Page = 0 });
Assert.That(searchResponse.Hits, Has.Exactly(5).Items);
// Instantiate a new SynonymIterator using newSynonymIterator and iterate over all the synonyms and check that those collected synonyms are the same as the 5 originally saved
List <Synonym> synonymsFromIterator = new List <Synonym>();
foreach (var synonym in new SynonymsIterator(_index))
{
synonymsFromIterator.Add(synonym);
}
Assert.True(TestHelper.AreObjectsEqual(gba, synonymsFromIterator.Find(s => s.ObjectID.Equals("gba"))));
Assert.True(TestHelper.AreObjectsEqual(wiiToWiiu,
synonymsFromIterator.Find(s => s.ObjectID.Equals("wii_to_wii_u"))));
Assert.True(TestHelper.AreObjectsEqual(playstationPlaceholder,
synonymsFromIterator.Find(s => s.ObjectID.Equals("playstation_version_placeholder"))));
Assert.True(TestHelper.AreObjectsEqual(ps4, synonymsFromIterator.Find(s => s.ObjectID.Equals("ps4"))));
Assert.True(TestHelper.AreObjectsEqual(psone, synonymsFromIterator.Find(s => s.ObjectID.Equals("psone"))));
// Delete the synonym with objectID=”gba” using deleteSynonym and wait for the task to terminate using waitTask with the returned taskID
var deleteGbaResponse = await _index.DeleteSynonymAsync("gba");
deleteGbaResponse.Wait();
// Try to get the synonym with getSynonym with objectID “gba” and check that the synonym does not exist anymore (404)
AlgoliaApiException ex = Assert.ThrowsAsync <AlgoliaApiException>(() => _index.GetSynonymAsync("gba"));
Assert.That(ex.HttpErrorCode, Is.EqualTo(404));
// Clear all the synonyms using clearSynonyms and wait for the task to terminate using waitTask with the returned taskID
var clearSynonymResponse = await _index.ClearSynonymsAsync();
clearSynonymResponse.Wait();
// Perform a synonym search using searchSynonyms with an empty query, page 0 and hitsPerPage set to 10 and check that the number of returned synonyms is equal to 0
SearchResponse <Synonym> searchAfterClearResponse =
await _index.SearchSynonymsAsync(new SynonymQuery { HitsPerPage = 10, Page = 0 });
Assert.That(searchAfterClearResponse.Hits, Is.Empty);
}
public async Task TestReplacing()
{
var addResponse = _index.SaveObjectAsync(new ReplaceAllTestObject {
ObjectID = "one"
});
var ruleToSave = new Rule
{
ObjectID = "one",
Condition = new Condition {
Anchoring = "is", Pattern = "pattern"
},
Consequence = new Consequence
{
Params = new ConsequenceParams
{
Query = new ConsequenceQuery
{
Edits = new List <Edit> {
new Edit {
Type = EditType.Remove, Delete = "pattern"
}
}
}
}
}
};
var saveRuleResponse = _index.SaveRuleAsync(ruleToSave);
var synonymToSave = new Synonym
{
ObjectID = "one",
Type = SynonymType.Synonym,
Synonyms = new List <string> {
"one", "two"
}
};
var saveSynonymResponse = _index.SaveSynonymAsync(synonymToSave);
Task.WaitAll(saveSynonymResponse, addResponse, saveRuleResponse);
addResponse.Result.Wait();
saveRuleResponse.Result.Wait();
saveSynonymResponse.Result.Wait();
var response = await _index.ReplaceAllObjectsAsync(new List <ReplaceAllTestObject>
{
new ReplaceAllTestObject {
ObjectID = "two"
}
});
response.Wait();
var ruleToSave2 = new Rule
{
ObjectID = "two",
Condition = new Condition {
Anchoring = "is", Pattern = "pattern"
},
Consequence = new Consequence
{
Params = new ConsequenceParams
{
Query = new ConsequenceQuery
{
Edits = new List <Edit> {
new Edit {
Type = EditType.Remove, Delete = "pattern"
}
}
}
}
}
};
var replaceAllRulesResponse = await _index.ReplaceAllRulesAsync(new List <Rule> {
ruleToSave2
});
var synonymToSave2 = new Synonym
{
ObjectID = "two",
Type = SynonymType.Synonym,
Synonyms = new List <string> {
"one", "two"
}
};
var replaceAllSynonymsResponse = await _index.ReplaceAllSynonymsAsync(new List <Synonym> {
synonymToSave2
});
replaceAllRulesResponse.Wait();
replaceAllSynonymsResponse.Wait();
AlgoliaApiException getObjectEx =
Assert.ThrowsAsync <AlgoliaApiException>(() => _index.GetObjectAsync <ReplaceAllTestObject>("one"));
AlgoliaApiException getSynonymEx =
Assert.ThrowsAsync <AlgoliaApiException>(() => _index.GetSynonymAsync("one"));
AlgoliaApiException getRuleEx = Assert.ThrowsAsync <AlgoliaApiException>(() => _index.GetRuleAsync("one"));
Assert.That(getObjectEx.HttpErrorCode, Is.EqualTo(404));
Assert.That(getSynonymEx.HttpErrorCode, Is.EqualTo(404));
Assert.That(getRuleEx.HttpErrorCode, Is.EqualTo(404));
var ruleAfterReplace = _index.GetRuleAsync("two");
var synonymAfterReplace = _index.GetSynonymAsync("two");
Task.WaitAll(ruleAfterReplace, synonymAfterReplace);
Assert.True(TestHelper.AreObjectsEqual(ruleAfterReplace.Result, ruleToSave2));
Assert.True(TestHelper.AreObjectsEqual(synonymAfterReplace.Result, synonymToSave2));
}
public async Task TestAbTest()
{
var now = DateTime.UtcNow.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
string testName = $"csharp-{now}-{Environment.UserName}";
var abTests = await BaseTest.AnalyticsClient.GetABTestsAsync();
if (abTests.ABTests != null)
{
var abTestsToDelete =
abTests.ABTests?.Where(x => x.Name.Contains("csharp-") && !x.Name.Contains($"csharp-{now}"));
foreach (var item in abTestsToDelete)
{
await BaseTest.AnalyticsClient.DeleteABTestAsync(item.AbTestId.Value);
}
}
var addOne = await _index1.SaveObjectAsync(new AlgoliaStub { ObjectID = "one" });
var addTwo = await _index2.SaveObjectAsync(new AlgoliaStub { ObjectID = "one" });
// Create tomorrow datetime without seconds/ms to avoid test to fail
DateTime utcNow = DateTime.UtcNow.AddDays(1);
DateTime tomorrow = new DateTime(utcNow.Year, utcNow.Month, utcNow.Day, utcNow.Hour, utcNow.Minute, 0,
utcNow.Kind);
var abTest = new ABTest
{
Name = testName,
Variants = new List <Variant>
{
new Variant
{
Index = _index1Name, TrafficPercentage = 60, Description = "a description"
},
new Variant
{
Index = _index2Name, TrafficPercentage = 40, Description = string.Empty
}
},
EndAt = tomorrow
};
addOne.Wait();
addTwo.Wait();
AddABTestResponse addAbTest = await BaseTest.AnalyticsClient.AddABTestAsync(abTest);
abTest.AbTestId = addAbTest.ABTestId;
_index1.WaitTask(addAbTest.TaskID);
ABTest abTestToCheck = await BaseTest.AnalyticsClient.GetABTestAsync(abTest.AbTestId.Value);
Assert.IsTrue(TestHelper.AreObjectsEqual(abTestToCheck, abTest, "CreatedAt", "Status", "ClickCount", "ConversionCount"));
Assert.IsFalse(abTestToCheck.Status.Equals("stopped"));
ABTestsReponse listAbTests = await BaseTest.AnalyticsClient.GetABTestsAsync();
Assert.IsTrue(listAbTests.ABTests.Any(x => x.AbTestId == abTest.AbTestId));
Assert.IsTrue(TestHelper.AreObjectsEqual(
listAbTests.ABTests.FirstOrDefault(x => x.AbTestId == abTest.AbTestId), abTest, "CreatedAt", "Status", "ClickCount", "ConversionCount"));
await BaseTest.AnalyticsClient.StopABTestAsync(abTest.AbTestId.Value);
ABTest stoppedAbTest = await BaseTest.AnalyticsClient.GetABTestAsync(abTest.AbTestId.Value);
Assert.IsTrue(stoppedAbTest.Status.Equals("stopped"));
DeleteABTestResponse deleteAbTest = await BaseTest.AnalyticsClient.DeleteABTestAsync(abTest.AbTestId.Value);
_index1.WaitTask(deleteAbTest.TaskID);
AlgoliaApiException ex =
Assert.ThrowsAsync <AlgoliaApiException>(() => BaseTest.AnalyticsClient.GetABTestAsync(abTest.AbTestId.Value));
Assert.That(ex.HttpErrorCode == 404);
}
