using NUnit.Framework;

using rosette_api;

using RichardSzalay.MockHttp;

using System;

using System.Collections.Generic;

using System.Collections.Specialized;

using System.IO;

using System.IO.Compression;

using System.Linq;

using System.Net;

using System.Net.Http;

using System.Web.Script.Serialization;

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using System.Threading.Tasks;

namespace rosette_apiUnitTests {

/// <summary>

/// Provides a concurrency test, non-unit. Keep commented out for release.

/// </summary>

[TestFixture]

public class ConcurrencyTest {

private static int threads = 3;

private static int calls = 5;

private static int loops = 1;

//[Test]

public void TestConcurrency() {

// To use the C# API, you must provide an API key

string apikey = Environment.GetEnvironmentVariable("API_KEY");

string alturl = string.Empty;

// Block on the test, otherwise the threads will exit before completion when main exits

while (loops-- > 0) {

StartTest(apikey, alturl).GetAwaiter().GetResult();

}

}

private static async Task StartTest(string apikey, string alturl) {

var tasks = new List<Task>();

CAPI api = string.IsNullOrEmpty(alturl) ? new CAPI(apikey) : new CAPI(apikey, alturl);

foreach (int task in Enumerable.Range(0, threads)) {

Console.WriteLine("Starting task {0}", task);

tasks.Add(Task.Factory.StartNew(() => runLookup(task, api)));

}

await Task.WhenAll(tasks);

Console.WriteLine("Test complete");

}

private static Task runLookup(int taskId, CAPI api) {

string entities_text_data = @"Bill Murray will appear in new Ghostbusters film: Dr. Peter Venkman was spotted filming a cameo in Boston this… http://dlvr.it/BnsFfS";

//string contentUri = "http://www.foxsports.com/olympics/story/chad-le-clos-showed-why-you-never-talk-trash-to-michael-phelps-080916";

foreach (int call in Enumerable.Range(0, calls)) {

Console.WriteLine("Task ID: {0} call {1}", taskId, call);

try {

var result = api.Entity(content: entities_text_data);

Console.WriteLine("Concurrency: {0},Rresult: {1}", api.Concurrency, result);

}

catch (Exception ex) {

Console.WriteLine(ex);

}

}

return Task.FromResult(0);

}

}

[TestFixture]

public class RosetteResponseTests {

private string _testHeaderKey;

private string _testHeaderValue;

private string _testJson;

private int _testItemCount;

[SetUp]

public void Init() {

_testHeaderKey = "X-RosetteAPI-RequestId";

_testHeaderValue = "123456789";

_testJson = @"{ ""item1"":""value1"", ""item2"":""value2""}";

_testItemCount = 2;

}

[Test]

public void RosetteResponse_HeaderTest() {

HttpResponseMessage message = new HttpResponseMessage {

StatusCode = (HttpStatusCode)200,

ReasonPhrase = "OK",

Content = new StringContent(_testJson)

};

message.Headers.Add(_testHeaderKey, _testHeaderValue);

RosetteResponse rr = new RosetteResponse(message);

Assert.AreEqual(_testHeaderValue, rr.Headers[_testHeaderKey], "RosetteResponse: header mismatch");

}

[Test]

public void RosetteResponse_ContentTest() {

HttpResponseMessage message = new HttpResponseMessage {

StatusCode = (HttpStatusCode)200,

ReasonPhrase = "OK",

Content = new StringContent(_testJson)

};

message.Headers.Add(_testHeaderKey, _testHeaderValue);

RosetteResponse rr = new RosetteResponse(message);

# pragma warning disable 618

Assert.AreEqual(_testItemCount, rr.Content.Count, "RosetteResponse: header mismatch");

# pragma warning restore 618

}

[Test]

public void RosetteResponse_ContentAsJsonTest() {

HttpResponseMessage message = new HttpResponseMessage {

StatusCode = (HttpStatusCode)200,

ReasonPhrase = "OK",

Content = new StringContent(_testJson)

};

message.Headers.Add(_testHeaderKey, _testHeaderValue);

RosetteResponse rr = new RosetteResponse(message);

Assert.AreEqual(_testJson, rr.ContentAsJson, "RosetteResponse: json mismatch");

}

[Test]

public void RosetteResponse_ExceptionTest() {

HttpResponseMessage message = new HttpResponseMessage {

StatusCode = (HttpStatusCode)404,

ReasonPhrase = "Not Found",

Content = new StringContent(_testJson)

};

message.Headers.Add(_testHeaderKey, _testHeaderValue);

try {

new RosetteResponse(message);

Assert.Fail("Exception should have been thrown");

}

catch (RosetteException ex) {

Assert.AreEqual(404, ex.Code, "RosetteResponse: Exception mismatch");

}

}

}

[TestFixture]

public class RosetteExtensionsTests {

[Test]

public void MorphologyEndpointTest() {

string expected = "han-readings";

Assert.AreEqual(expected, RosetteExtensions.MorphologyEndpoint(MorphologyFeature.hanReadings), "Morphology endpoint mismatch");

}

}

[TestFixture]

public class Rosette_errorTests : IDisposable {

bool disposed = false;

public void Dispose() {

Dispose(true);

GC.SuppressFinalize(this);

}

protected virtual void Dispose(bool disposing) {

if (disposed) {

return;

}

if (disposing) {

_mockHttp.Dispose();

}

disposed = true;

}

private MockHttpMessageHandler _mockHttp;

private CAPI _rosetteApi;

private string _testUrl = @"https://analytics.babelstreet.com/rest/v1/";

[OneTimeSetUp]

public void Init() {

_mockHttp = new MockHttpMessageHandler();

var client = new HttpClient(_mockHttp);

string jsonResponse = string.Format("{{'response': 'OK', 'version': '{0}'}}", CAPI.Version);

_mockHttp.When(_testUrl + "info")

.WithQueryString(string.Format("clientVersion={0}", CAPI.Version))

.Respond("applciation/json", jsonResponse);

_rosetteApi = new CAPI("userkey", null, 1, client);

}

[OneTimeTearDown]

public void Cleanup() {

}

[Test]

public void Error409_Test() {

try {

_mockHttp.When(_testUrl + "entities").Respond(HttpStatusCode.Conflict);

_rosetteApi.Entity("content");

Assert.Fail("Exception not thrown");

}

catch (RosetteException ex) {

Console.WriteLine("Error code: " + ex.Code);

Assert.AreEqual(ex.Code, 409);

return;

}

catch (Exception) {

Assert.Fail("RosetteException not thrown");

return;

}

}

}

[TestFixture]

public class Rosette_classTests {

[Test]

public void NameClassTest() {

Name name = new Name("text", "language", "script", "entityType");

Assert.AreEqual("text", name.text, "Name does not match");

Assert.AreEqual("language", name.language, "Language does not match");

Assert.AreEqual("script", name.script, "Script does not match");

Assert.AreEqual("entityType", name.entityType, "EntityType does not match");

}

[Test]

public void RosetteFileClassTest() {

string tmpFile = Path.GetTempFileName();

StreamWriter sw = File.AppendText(tmpFile);

sw.WriteLine("Rosette API Unit Test");

sw.Flush();

sw.Close();

RosetteFile f = new RosetteFile(tmpFile, "application/octet-stream", null);

Assert.IsNotNull(f.Filename, "Filename is null");

Assert.AreEqual(tmpFile, f.Filename, "Filename does not match");

Assert.AreEqual("application/octet-stream", f.ContentType, "ContentType does not match");

Assert.IsNull(f.Options, "Options does not match");

byte[] b = f.getFileData();

Assert.IsTrue(b.Count() > 0, "File is empty");

string content = f.getFileDataString();

Assert.IsTrue(content.Length > 0, "File is empty");

MultipartContent multiPart = f.AsMultipart();

Assert.IsTrue(multiPart.Headers.Count() > 0, "Multipart not populated");

f.Dispose();

if (File.Exists(tmpFile)) {

File.Delete(tmpFile);

}

}

[Test]

public void RosetteExceptionClassTest() {

RosetteException ex = new RosetteException("message", 1, "requestID", "file", "line");

Assert.AreEqual("message", ex.Message, "Message does not match");

Assert.AreEqual(1, ex.Code, "Code does not match");

Assert.AreEqual("requestID", ex.RequestID, "RequestID does not match");

Assert.AreEqual("file", ex.File, "File does not match");

Assert.AreEqual("line", ex.Line, "Line does not match");

}

}

[TestFixture]

public class Rosette_serializationTests {

[Test]

public void RecordFieldTypeSerializationTest() {

string date = RecordFieldType.RniDate;

string address = RecordFieldType.RniAddress;

string name = RecordFieldType.RniName;

string str = RecordFieldType.RniString;

string number = RecordFieldType.RniNumber;

string boolean = RecordFieldType.RniBoolean;

string dateSerialized = JsonConvert.SerializeObject(date);

string addressSerialized = JsonConvert.SerializeObject(address);

string nameSerialized = JsonConvert.SerializeObject(name);

string strSerialized = JsonConvert.SerializeObject(str);

string numberSerialized = JsonConvert.SerializeObject(number);

string booleanSerialized = JsonConvert.SerializeObject(boolean);

Assert.AreEqual( "\"rni_date\"", dateSerialized, "RniDate does not deserialize to 'rni_date'");

Assert.AreEqual("\"rni_address\"", addressSerialized, "RniAddress does not deserialize to 'rni_address'");

Assert.AreEqual("\"rni_name\"", nameSerialized, "RniName does not deserialize to 'rni_name'");

Assert.AreEqual("\"rni_string\"", strSerialized, "RniString does not deserialize to 'rni_string'");

Assert.AreEqual("\"rni_number\"", numberSerialized, "RniNumber does not deserialize to 'rni_number'");

Assert.AreEqual("\"rni_boolean\"", booleanSerialized, "RniBoolean does not deserialize to 'rni_boolean'");

}

[Test]

public void RecordSimilarityFieldSerializationTest() {

RecordSimilarityField addressUnfielded = new UnfieldedAddressRecord("123 Roadlane Ave");

string addressUnfieldedSerialized = JsonConvert.SerializeObject(addressUnfielded);

RecordSimilarityField nameUnfielded = new UnfieldedNameRecord("Ethan R");

string nameUnfieldedSerialized = JsonConvert.SerializeObject(nameUnfielded);

RecordSimilarityField dateUnfielded = new UnfieldedDateRecord("1993-04-16");

string dateUnfieldedSerialized = JsonConvert.SerializeObject(dateUnfielded);

Assert.AreEqual("\"123 Roadlane Ave\"", addressUnfieldedSerialized, "Unfielded Address does not serialize correctly");

Assert.AreEqual("\"Ethan R\"", nameUnfieldedSerialized, "Unfielded Name does not serialize correctly");

Assert.AreEqual("\"1993-04-16\"", dateUnfieldedSerialized, "Unfielded Date does not serialize correctly");

FieldedAddressRecord addressFielded = new FieldedAddressRecord();

addressFielded.HouseNumber = "123";

addressFielded.Road = "Roadlane Ave";

string addressFieldedSerialized = JsonConvert.SerializeObject(addressFielded, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });

RecordSimilarityField nameFielded = new FieldedNameRecord("Ethan R");

// keys in order: text, language, languageOfOrigin, script, entityType

string nameFieldedSerialized = JsonConvert.SerializeObject(nameFielded, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });

RecordSimilarityField dateFielded = new FieldedDateRecord("04161993", "MMddyyyy");

string dateFieldedSerialized = JsonConvert.SerializeObject(dateFielded);

Assert.AreEqual("{\"houseNumber\":\"123\",\"road\":\"Roadlane Ave\"}", addressFieldedSerialized, "Fielded Address does not serialize correctly");

Assert.AreEqual("{\"text\":\"Ethan R\"}", nameFieldedSerialized, "Fielded Name does not serialize correctly");

Assert.AreEqual("{\"format\":\"MMddyyyy\",\"date\":\"04161993\"}", dateFieldedSerialized, "Fielded Date does not serialize correctly");

string jsonString = "{\"key\":\"value\",\"key2\":[\"value2\",\"value3\"]}";

RecordSimilarityField unknownField = new UnknownFieldRecord(JToken.Parse(jsonString));

string unknownFieldSerialized = JsonConvert.SerializeObject(unknownField);

Assert.AreEqual(jsonString, unknownFieldSerialized, "Unknown Field does not serialize correctly");

RecordSimilarityField stringField = new StringRecord("software engineer");

string stringFieldSerialized = JsonConvert.SerializeObject(stringField);

Assert.AreEqual("\"software engineer\"", stringFieldSerialized, "String Field does not serialize correctly");

RecordSimilarityField numberField = new NumberRecord(47);

string numberFieldSerialized = JsonConvert.SerializeObject(numberField);

Assert.AreEqual("47.0", numberFieldSerialized, "Number Field does not serialize correctly");

RecordSimilarityField booleanField = new BooleanRecord(false);

string booleanFieldSerialized = JsonConvert.SerializeObject(booleanField);

Assert.AreEqual("false", booleanFieldSerialized, "Boolean Field does not serialize correctly");

}

[Test]

public void RecodSimilarityFullResponseDeserializationTest() {

string jsonResponse = "{\"info\":[\"Threshold not specified, defaulting to 0.0\",\"IncludeExplainInfo not specified, defaulting to false\"],\"results\":[{\"score\":0.904213806305046,\"left\":{\"dob\":{\"date\":\"1993-04-16\"},\"primaryName\":{\"text\":\"Evan R\"}},\"right\":{\"dob\":{\"date\":\"1993-04-16\"},\"primaryName\":\"Ivan R\"},\"explainInfo\":{\"scoredFields\":{\"dob\":{\"weight\":0.2,\"calculatedWeight\":0.28571428571428575,\"rawScore\":1,\"finalScore\":0.28571428571428575,\"details\":{\"leftInput\":{\"originalString\":\"1993-04-16\",\"day\":16,\"month\":4,\"yearWithoutCentury\":93,\"century\":19,\"modifiedJulianDay\":49093,\"canonicalForm\":\"1993-04-16\",\"empty\":false},\"rightInput\":{\"originalString\":\"1993-04-16\",\"day\":16,\"month\":4,\"yearWithoutCentury\":93,\"century\":19,\"modifiedJulianDay\":49093,\"canonicalForm\":\"1993-04-16\",\"empty\":false},\"scoreTuples\":[{\"scoreInIsolation\":1,\"scoreInContext\":1,\"left\":\"1993-04-16\",\"right\":\"1993-04-16\",\"marked\":true,\"weight\":1,\"component\":\"EXACT_MATCH\"}],\"scoreAdjustments\":[{\"unbiasedScore\":1,\"score\":1,\"parameter\":\"dateFinalBias\"}],\"finalScore\":1,\"scores\":[{\"scoreInIsolation\":1,\"scoreInContext\":1,\"left\":\"1993-04-16\",\"right\":\"1993-04-16\",\"marked\":true,\"weight\":1,\"component\":\"EXACT_MATCH\"}],\"defaultInput\":{\"empty\":true},\"empty\":false}},\"primaryName\":{\"weight\":0.5,\"calculatedWeight\":0.7142857142857143,\"rawScore\":0.8658993288270642,\"finalScore\":0.6184995205907602,\"details\":{\"leftInput\":{\"data\":\"Evan R\",\"normalizedData\":\"evan r\",\"latnData\":\"evan r\",\"script\":\"Latn\",\"languageOfUse\":\"ENGLISH\",\"languageOfOrigin\":\"ENGLISH\",\"tokens\":[{\"token\":\"evan\",\"latnToken\":\"evan\",\"tokenWeight\":0.7213975215425366,\"bin\":3,\"biasedBin\":2.902736521062578,\"tokenType\":\"GIVEN\"},{\"token\":\"r\",\"latnToken\":\"r\",\"tokenWeight\":0.27860247845746355,\"bin\":8,\"biasedBin\":7.5161819937120935,\"tokenType\":\"UNKNOWN\"}],\"entityType\":\"PERSON\",\"empty\":false},\"rightInput\":{\"data\":\"Ivan R\",\"normalizedData\":\"ivan r\",\"latnData\":\"ivan r\",\"script\":\"Latn\",\"languageOfUse\":\"ENGLISH\",\"languageOfOrigin\":\"SPANISH\",\"tokens\":[{\"token\":\"ivan\",\"latnToken\":\"ivan\",\"tokenWeight\":0.7213975215425366,\"bin\":3,\"biasedBin\":2.902736521062578,\"tokenType\":\"UNKNOWN\"},{\"token\":\"r\",\"latnToken\":\"r\",\"tokenWeight\":0.27860247845746355,\"bin\":8,\"biasedBin\":7.5161819937120935,\"tokenType\":\"UNKNOWN\"}],\"entityType\":\"PERSON\",\"empty\":false},\"scoreTuples\":[{\"scoreInIsolation\":0.6599663295739067,\"scoreInContext\":0.6599663295739067,\"left\":\"evan\",\"right\":\"ivan\",\"marked\":true,\"reason\":\"HMM_MATCH\",\"leftMinTokenIndex\":0,\"leftMaxTokenIndex\":0,\"rightMinTokenIndex\":0,\"rightMaxTokenIndex\":0},{\"scoreInIsolation\":1,\"scoreInContext\":1,\"left\":\"r\",\"right\":\"r\",\"marked\":true,\"reason\":\"MATCH\",\"leftMinTokenIndex\":1,\"leftMaxTokenIndex\":1,\"rightMinTokenIndex\":1,\"rightMaxTokenIndex\":1}],\"scoreAdjustments\":[{\"unbiasedScore\":0.7290304644108475,\"score\":0.8658993288270642,\"parameter\":\"finalBias\"}],\"finalScore\":0.8658993288270642,\"defaultInput\":{\"empty\":true},\"empty\":false}}},\"leftOnlyFields\":[],\"rightOnlyFields\":[]}}],\"errorMessage\":\"dummy\"}";

// create a HttpResponseMessage from this JSON

HttpResponseMessage message = new HttpResponseMessage {

StatusCode = (HttpStatusCode)200,

ReasonPhrase = "OK",

Content = new StringContent(jsonResponse)

};

RecordSimilarityResponse response = new RecordSimilarityResponse(message);

// Assert info messages

Assert.IsNotNull(response.Info, "Info is null");

Assert.AreEqual(2, response.Info.Count, "Info count does not match");

Assert.AreEqual("Threshold not specified, defaulting to 0.0", response.Info[0], "Info message 0 does not match");

Assert.AreEqual("IncludeExplainInfo not specified, defaulting to false", response.Info[1], "Info message 1 does not match");

// Assert error message

Assert.AreEqual("dummy", response.ErrorMessage, "Error message does not match");

// Assert result

Assert.IsNotNull(response.Results, "Results is null");

Assert.AreEqual(1, response.Results.Count, "Results count does not match");

RecordSimilarityResult result = response.Results[0];

Assert.AreEqual(0.904213806305046, result.Score, "Score does not match");

Assert.IsNotNull(result.Left, "Left is null");

Assert.AreEqual(2, result.Left.Count, "Left count does not match");

Assert.IsNotNull(result.Right, "Right is null");

Assert.AreEqual(2, result.Right.Count, "Right count does not match");

// Assert explainInfo

RecordSimilarityExplainInfo explainInfo = result.ExplainInfo;

Assert.IsNotNull(result.ExplainInfo, "ExplainInfo is null");

Assert.IsNotNull(explainInfo.RightOnlyFields, "RightOnlyFields is null");

Assert.AreEqual(0, explainInfo.RightOnlyFields.Count, "RightOnlyFields count does not match");

Assert.IsNotNull(explainInfo.LeftOnlyFields, "LeftOnlyFields is null");

Assert.AreEqual(0, explainInfo.LeftOnlyFields.Count, "LeftOnlyFields count does not match");

// Assert scoredFields is not null and has both keys

Assert.IsNotNull(explainInfo.ScoredFields, "ScoredFields is null");

Assert.IsTrue(explainInfo.ScoredFields.ContainsKey("dob"), "ScoredFields does not contain key 'dob'");

Assert.IsTrue(explainInfo.ScoredFields.ContainsKey("primaryName"), "ScoredFields does not contain key 'primaryName'");

// Assert dob

RecordSimilarityFieldExplainInfo dob = explainInfo.ScoredFields["dob"];

Assert.IsNotNull(dob, "dob is null");

Assert.AreEqual(0.2, dob.Weight, "dob weight does not match");

Assert.AreEqual(0.28571428571428575, dob.CalculatedWeight, "dob calculated weight does not match");

Assert.AreEqual(1, dob.RawScore, "dob raw score does not match");

Assert.AreEqual(0.28571428571428575, dob.FinalScore, "dob final score does not match");

Assert.IsNotNull(dob.Details, "dob details is null");

}

}

[TestFixture]

public class Rosette_apiUnitTests : IDisposable {

bool disposed = false;

public void Dispose() {

Dispose(true);

GC.SuppressFinalize(this);

}

protected virtual void Dispose(bool disposing) {

if (disposed) {

return;

}

if (disposing) {

_mockHttp.Dispose();

}

disposed = true;

}

/// <summary>Compress

/// <para>

/// Takes in byte data and compresses it using gzip.

/// Source: http://www.dotnetperls.com/compress

/// </para>

/// </summary>

/// <param name="raw">(byte[]): Raw data to be compressed</param>

/// <returns>(byte[]): Compressed data</returns>

public static byte[] Compress(byte[] raw) {

MemoryStream memory = new MemoryStream();

using (GZipStream gzip = new GZipStream(memory, CompressionMode.Compress, true)) {

gzip.Write(raw, 0, raw.Length);

}

return memory.ToArray();

}

/// <summary>Decompress

/// <para>Method to decompress GZIP files

/// Source: http://www.dotnetperls.com/decompress

/// </para>

/// </summary>

/// <param name="gzip">(byte[]): Data in byte form to decompress</param>

/// <returns>(byte[]) Decompressed data</returns>

private static byte[] Decompress(byte[] gzip) {

// Create a GZIP stream with decompression mode.

// ... Then create a buffer and write into while reading from the GZIP stream.

using (GZipStream stream = new GZipStream(new MemoryStream(gzip), CompressionMode.Decompress)) {

const int size = 4096;

byte[] buffer = new byte[size];

using (MemoryStream memory = new MemoryStream()) {

int count = 0;

do {

count = stream.Read(buffer, 0, size);

if (count > 0) {

memory.Write(buffer, 0, count);

}

}

while (count > 0);

return memory.ToArray();

}

}

}

private MockHttpMessageHandler _mockHttp;

private CAPI _rosetteApi;

private string _testUrl = @"https://analytics.babelstreet.com/rest/v1/";

private string _tmpFile = null;

[OneTimeSetUp]

public void Init() {

// Create a temporary file for use with file testing

_tmpFile = Path.GetTempFileName();

StreamWriter sw = File.AppendText(_tmpFile);

sw.WriteLine("Rosette API Unit Test. This file is used for testing file operations.");

sw.Flush();

sw.Close();

_mockHttp = new MockHttpMessageHandler();

var client = new HttpClient(_mockHttp);

string jsonResponse = string.Format("{{'response': 'OK', 'version': '{0}'}}", CAPI.Version);

_mockHttp.When(_testUrl + "info")

.WithQueryString(string.Format("clientVersion={0}", CAPI.Version))

.Respond("applciation/json", jsonResponse);

_rosetteApi = new CAPI("userkey", null, 1, client);

}

[OneTimeTearDown]

public void Cleanup() {

if (File.Exists(_tmpFile)) {

File.Delete(_tmpFile);

}

_mockHttp.Clear();

}

//------------------------- User-Agent Test ----------------------------------------

[Test]

public void UserAgentTest() {

string uaString = string.Format("Babel-Street-Analytics-API-Csharp/{0}/{1}", CAPI.Version, Environment.Version.ToString());

Assert.AreEqual(uaString, _rosetteApi.UserAgent);

}

//------------------------- Simple Options Tests ----------------------------------------

[Test]

public void OptionsTest() {

KeyValuePair<string, string> expected = new KeyValuePair<string, string>("test", "testValue");

_rosetteApi.SetOption(expected.Key, expected.Value);

Assert.AreEqual(expected.Value, _rosetteApi.GetOption(expected.Key));

}

[Test]

public void ClearOptionsTest() {

_rosetteApi.SetOption("option1", "value1");

_rosetteApi.SetOption("option2", "value2");

_rosetteApi.ClearOptions();

Assert.IsNull(_rosetteApi.GetOption("option1"));

}

//------------------------- Simple Custom Header Tests ----------------------------------------

[Test]

public void CustomHeadersTestRosette() {

KeyValuePair<string, string> expected = new KeyValuePair<string, string>("X-RosetteAPI-Test", "testValue");

_rosetteApi.SetCustomHeaders(expected.Key, expected.Value);

Assert.AreEqual(expected.Value, _rosetteApi.GetCustomHeaders()[expected.Key]);

}

[Test]

public void CustomHeadersTestBabelStreet() {

KeyValuePair<string, string> expected = new KeyValuePair<string, string>("X-BabelStreetAPI-Test", "testValue");

_rosetteApi.SetCustomHeaders(expected.Key, expected.Value);

Assert.AreEqual(expected.Value, _rosetteApi.GetCustomHeaders()[expected.Key]);

}

[Test]

public void ClearHeadersTest() {

_rosetteApi.SetCustomHeaders("X-RosetteAPI-Test", "testValue");

_rosetteApi.ClearCustomHeaders();

Assert.IsEmpty(_rosetteApi.GetCustomHeaders());

}

[Test]

public void CheckInvalidCustomHeader() {

KeyValuePair<string, string> expected = new KeyValuePair<string, string>("Test", "testValue");

try {

_rosetteApi.SetCustomHeaders(expected.Key, expected.Value);

}

catch (RosetteException ex) {

Assert.AreEqual(ex.Message, "Custom header name must begin with \"X-RosetteAPI-\" or \"X-BabelStreetAPI-\"");

return;

}

}

//------------------------- Simple URL Parameter Tests ----------------------------------------

[Test]

public void CustomUrlParametersTest() {

NameValueCollection expected = new NameValueCollection {

{ "output", "rosette" }

};

_rosetteApi.SetUrlParameter("output", "rosette");

Assert.AreEqual(expected["output"], _rosetteApi.GetUrlParameters()["output"]);

}

[Test]

public void ClearUrlParametersTest() {

NameValueCollection expected = new NameValueCollection {

{ "output", "rosette" }

};

_rosetteApi.SetUrlParameter("output", "rosette");

_rosetteApi.ClearUrlParameters();

Assert.IsEmpty(_rosetteApi.GetUrlParameters());

}

[Test]

public void RemoveURLParametersTest() {

NameValueCollection expected = new NameValueCollection {

{ "output", "rosette" }

};

_rosetteApi.RemoveUrlParameter("output");

Assert.IsEmpty(_rosetteApi.GetUrlParameters());

}

//------------------------- Get Calls (Info and Ping) ----------------------------------------

[Test]

public void InfoTest() {

_mockHttp.When(_testUrl + "info")

.Respond("application/json", "{'response': 'OK'}");

var response = _rosetteApi.Info();

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

[Test]

public void InfoTestFull()

{

Init();

string name = "Rosette API";

string version = "1.2.3";

string buildNumber = null;

string buildTime = null;

string headersAsString = " { \"Content-Type\": \"application/json\", \"Date\": \"Thu, 11 Aug 2016 15:47:32 GMT\", \"Server\": \"openresty\", \"Strict-Transport-Security\": \"max-age=63072000; includeSubdomains; preload\", \"x-rosetteapi-app-id\": \"1409611723442\", \"x-rosetteapi-concurrency\": \"50\", \"x-rosetteapi-request-id\": \"d4176692-4f14-42d7-8c26-4b2d8f7ff049\", \"Content-Length\": \"72\", \"Connection\": \"Close\" }";

Dictionary<string, object> content = new Dictionary<string, object> {

{ "name", name },

{ "version", version },

{ "buildNumber", buildNumber },

{ "buildTime", buildTime }

};

Dictionary<string, string> responseHeaders = new JavaScriptSerializer().Deserialize<Dictionary<string, string>>(headersAsString);

HttpResponseMessage mockedMessage = MakeMockedMessage(responseHeaders, HttpStatusCode.OK, new JavaScriptSerializer().Serialize(content));

_mockHttp.When(_testUrl + "info").Respond(req => mockedMessage);

InfoResponse expected = new InfoResponse(name, version, buildNumber, buildTime, responseHeaders, content);

InfoResponse response = _rosetteApi.Info();

Assert.AreEqual(expected, response);

}

private HttpResponseMessage MakeMockedMessage(Dictionary<string, string> responseHeaders, HttpStatusCode statusCode, String content)

{

HttpResponseMessage mockedMessage = new HttpResponseMessage(statusCode) {

Content = new StringContent(content)

};

foreach (KeyValuePair<string, string> header in responseHeaders)

{

try

{

mockedMessage.Headers.Add(header.Key, header.Value.ToString());

}

catch

{

try

{

mockedMessage.Content.Headers.Add(header.Key, header.Value.ToString());

}

catch

{

switch (header.Key)

{

case "Content-Type": mockedMessage.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(header.Value);

break;

case "content-length": mockedMessage.Content.Headers.ContentLength = long.Parse(header.Value);

break;

default: throw;

}

}

}

}

return mockedMessage;

}

[Test]

public void PingTestFull() {

Init();

string message = "Rosette API at your service.";

long time = 1470930452887;

string headersAsString = " { \"Content-Type\": \"application/json\", \"Date\": \"Thu, 11 Aug 2016 15:47:32 GMT\", \"Server\": \"openresty\", \"Strict-Transport-Security\": \"max-age=63072000; includeSubdomains; preload\", \"x-rosetteapi-app-id\": \"1409611723442\", \"x-rosetteapi-concurrency\": \"50\", \"x-rosetteapi-request-id\": \"d4176692-4f14-42d7-8c26-4b2d8f7ff049\", \"Content-Length\": \"72\", \"Connection\": \"Close\" }";

Dictionary<string, object> content = new Dictionary<string, object> {

{ "message", message },

{ "time", time }

};

Dictionary<string, string> responseHeaders = new JavaScriptSerializer().Deserialize<Dictionary<string, string>>(headersAsString);

HttpResponseMessage mockedMessage = MakeMockedMessage(responseHeaders, HttpStatusCode.OK, new JavaScriptSerializer().Serialize(content));

_mockHttp.When(_testUrl + "ping").Respond(req => mockedMessage);

PingResponse expected = new PingResponse(message, time, responseHeaders, content);

PingResponse response = _rosetteApi.Ping();

Assert.AreEqual(expected, response);

}

[Test]

public void PingTest()

{

_mockHttp.When(_testUrl + "ping")

.Respond("application/json", "{'response': 'OK'}");

var response = _rosetteApi.Ping();

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

//------------------------- Exceptions ----------------------------------------

// Currently, the two exceptions returned by the binding (not server) occur if

// neither content nor contentUri are provided or both are provided. Categories is

// used for convenience, but the tests could be run against almost all of the

// endpoints.

[Test]

public void NoParams_Test() {

_mockHttp.When(_testUrl + "categories")

.Respond("application/json", "{'response': 'OK'}");

try {

_rosetteApi.Categories();

}

catch (RosetteException ex) {

Assert.AreEqual(ex.Message, "Must supply one of Content or ContentUri");

return;

}

Assert.Fail("Exception not thrown");

}

[Test]

public void ConflictingParams_Test() {

_mockHttp.When(_testUrl + "categories")

.Respond("application/json", "{'response': 'OK'}");

try {

_rosetteApi.Categories("content", null, null, "contentUri");

}

catch (RosetteException ex) {

Assert.AreEqual(ex.Message, "Cannot supply both Content and ContentUri");

return;

}

Assert.Fail("Exception not thrown");

}

//------------------------- Address Similarity ----------------------------------------

[Test]

public void AddressSimilarityTestFull()

{

Init();

double score = (double)0.9486632809417912;

string headersAsString = " { \"Content-Type\": \"application/json\", \"Date\": \"Thu, 11 Aug 2016 15:47:32 GMT\", \"Server\": \"openresty\", \"Strict-Transport-Security\": \"max-age=63072000; includeSubdomains; preload\", \"x-rosetteapi-app-id\": \"1409611723442\", \"x-rosetteapi-concurrency\": \"50\", \"x-rosetteapi-request-id\": \"d4176692-4f14-42d7-8c26-4b2d8f7ff049\", \"Content-Length\": \"72\", \"Connection\": \"Close\" }";

Dictionary<string, string> responseHeaders = new JavaScriptSerializer().Deserialize<Dictionary<string, string>>(headersAsString);

Dictionary<string, object> content = new Dictionary<string, object> {

{ "score", score }

};

AddressSimilarityResponse expected = new AddressSimilarityResponse(score, responseHeaders, content, null);

String mockedContent = expected.ContentToString();

HttpResponseMessage mockedMessage = MakeMockedMessage(responseHeaders, HttpStatusCode.OK, mockedContent);

_mockHttp.When(_testUrl + "address-similarity").Respond(req => mockedMessage);

AddressSimilarityResponse response = _rosetteApi.AddressSimilarity(new Address(city:"Cambridge"), new Address(city:"cambridge"));

Assert.AreEqual(expected, response);

}

[Test]

public void AddressSimilarity_Content_Test() {

_mockHttp.When(_testUrl + "address-similarity").Respond(HttpStatusCode.OK, "application/json", "{'response': 'OK'}");

Address name1 = new Address("Address One");

Address name2 = new Address("Address Two");

var response = _rosetteApi.AddressSimilarity(name1, name2);

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

[Test]

public void AddressSimilarity_Dict_Test() {

_mockHttp.When(_testUrl + "address-similarity")

.Respond(HttpStatusCode.OK, "application/json", "{'response': 'OK'}");

var response = _rosetteApi.AddressSimilarity(new Dictionary<object, object>() { { "address1", "Address One" }, { "address2", "Address Two" } });

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

//------------------------- Categories ----------------------------------------

[Test]

public void Categories_Content_Test() {

_mockHttp.When(_testUrl + "categories")

.Respond(HttpStatusCode.OK, "application/json", "{'response': 'OK'}");

var response = _rosetteApi.Categories("content");

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

[Test]

public void CategoriesContentTestFull()

{

Init();

JsonSerializer serializer = new JsonSerializer();

List<RosetteCategory> categories = new List<RosetteCategory>();

RosetteCategory cat0 = new RosetteCategory("ARTS_AND_ENTERTAINMENT", (decimal)0.23572849069656435, (decimal)0.12312312312312312);

categories.Add(cat0);

string headersAsString = " { \"Content-Type\": \"application/json\", \"Date\": \"Thu, 11 Aug 2016 15:47:32 GMT\", \"Server\": \"openresty\", \"Strict-Transport-Security\": \"max-age=63072000; includeSubdomains; preload\", \"x-rosetteapi-app-id\": \"1409611723442\", \"x-rosetteapi-concurrency\": \"50\", \"x-rosetteapi-request-id\": \"d4176692-4f14-42d7-8c26-4b2d8f7ff049\", \"Content-Length\": \"72\", \"Connection\": \"Close\" }";

Dictionary<string, object> content = new Dictionary<string, object> {

{ "categories", categories }

};

Dictionary<string, string> responseHeaders = serializer.Deserialize<Dictionary<string, string>>(new JsonTextReader(new StringReader(headersAsString)));

String mockedContent = "{\"categories\": [ { \"label\": \"" + cat0.Label + "\", \"confidence\": " + cat0.Confidence + ", \"score\": " + cat0.Score + "} ] }";

HttpResponseMessage mockedMessage = MakeMockedMessage(responseHeaders, HttpStatusCode.OK, mockedContent);

_mockHttp.When(_testUrl + "categories").Respond(req => mockedMessage);

CategoriesResponse expected = new CategoriesResponse(categories, responseHeaders, null, mockedContent);

CategoriesResponse response = _rosetteApi.Categories("Sony Pictures is planning to shoot a good portion of the new \"\"Ghostbusters\"\" in Boston as well.");

Assert.AreEqual(expected, response);

}

[Test]

public void Categories_Dict_Test() {

_mockHttp.When(_testUrl + "categories")

.Respond(HttpStatusCode.OK, "application/json", "{'response': 'OK'}");

var response = _rosetteApi.Categories(new Dictionary<object, object>(){ {"contentUri", "contentUrl"} });

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

[Test]

public void Categories_File_Test() {

_mockHttp.When(_testUrl + "categories")

.Respond("application/json", "{'response': 'OK'}");

RosetteFile f = new RosetteFile(_tmpFile);

var response = _rosetteApi.Categories(f);

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

//------------------------- Entity ----------------------------------------

[Test]

public void EntityTestFull()

{

Init();

RosetteEntity e0 = new RosetteEntity("Dan Akroyd", "Dan Akroyd", new EntityID("Q105221"), "PERSON", 2, 0.99, "X1", null, new List<MentionOffset>() { new MentionOffset(0, 10), new MentionOffset(20,32) }, .99, 1, null);

RosetteEntity e1 = new RosetteEntity("The Hollywood Reporter", "The Hollywood Reporter", new EntityID("Q61503"), "ORGANIZATION", 1, null, "X1", null, new List<MentionOffset>() { new MentionOffset(15, 18) }, null, null, null);

RosetteEntity e2 = new RosetteEntity("Dan Akroyd", "Dan Akroyd", new EntityID("Q105221"), "PERSON", 2, 0.99, "X1", null, new List<MentionOffset>() { new MentionOffset(0, 10), new MentionOffset(20, 32) }, .99, 0.0, null);

List<RosetteEntity> entities = new List<RosetteEntity>() { e0, e1, e2 };

string headersAsString = " { \"Content-Type\": \"application/json\", \"Date\": \"Thu, 11 Aug 2016 15:47:32 GMT\", \"Server\": \"openresty\", \"Strict-Transport-Security\": \"max-age=63072000; includeSubdomains; preload\", \"x-rosetteapi-app-id\": \"1409611723442\", \"x-rosetteapi-concurrency\": \"50\", \"x-rosetteapi-request-id\": \"d4176692-4f14-42d7-8c26-4b2d8f7ff049\", \"Content-Length\": \"72\", \"Connection\": \"Close\" }";

Dictionary<string, string> responseHeaders = new JavaScriptSerializer().Deserialize<Dictionary<string, string>>(headersAsString);

Dictionary<string, object> content = new Dictionary<string, object> {

{ "entities", entities }

};

EntitiesResponse expected = new EntitiesResponse(entities, responseHeaders, content, null);

String mockedContent = expected.ContentToString();

HttpResponseMessage mockedMessage = MakeMockedMessage(responseHeaders, HttpStatusCode.OK, mockedContent);

_mockHttp.When(_testUrl + "entities").Respond(req => mockedMessage);

EntitiesResponse response = _rosetteApi.Entity("Original Ghostbuster Dan Aykroyd, who also co-wrote the 1984 Ghostbusters film, couldn’t be more pleased with the new all-female Ghostbusters cast, telling The Hollywood Reporter, “The Aykroyd family is delighted by this inheritance of the Ghostbusters torch by these most magnificent women in comedy.”");

Assert.AreEqual(expected, response);

}

[Test]

public void EntityTestExtendedProperties() {

// Entities response, based on Cloud defaults, with linkEntities,

// includeDBpediaType, includeDBpediaTypes and includePermID set to true.

Init();

String e_type = "ORGANIZATION";

String e_mention = "Toyota";

String e_normalized = "Toyota";

Nullable<int> e_count = 1;

Nullable<double> e_confidence = null;

List<MentionOffset> e_mentionOffsets = new List<MentionOffset>() { new MentionOffset(0, 6) };

EntityID e_entityID = new EntityID("Q53268");

Nullable<double> e_linkingConfidence = 0.14286868;

Nullable<double> e_salience = null;

String e_dbpediaType = "Agent/Organisation";

List<String> e_dbpediaTypes = new List<String>() {"Agent/Organisation"};

String e_permId = "4295876746";

RosetteEntity e = new RosetteEntity(e_mention, e_normalized, e_entityID, e_type, e_count, e_confidence,

e_dbpediaType, e_dbpediaTypes, e_mentionOffsets, e_linkingConfidence, e_salience, e_permId);

List<RosetteEntity> entities = new List<RosetteEntity>() { e };

Dictionary<string, object> content = new Dictionary<string, object> { { "entities", entities } };

string headersAsString = " { \"Content-Type\": \"application/json\", \"Date\": \"Thu, 11 Aug 2016 15:47:32 GMT\", \"Server\": \"openresty\", \"Strict-Transport-Security\": \"max-age=63072000; includeSubdomains; preload\", \"x-rosetteapi-app-id\": \"1409611723442\", \"x-rosetteapi-concurrency\": \"50\", \"x-rosetteapi-request-id\": \"d4176692-4f14-42d7-8c26-4b2d8f7ff049\", \"Content-Length\": \"72\", \"Connection\": \"Close\" }";

Dictionary<string, string> responseHeaders = new JavaScriptSerializer().Deserialize<Dictionary<string, string>>(headersAsString);

EntitiesResponse expected = new EntitiesResponse(entities, responseHeaders, content, null);

String mockedContent = expected.ContentToString();

HttpResponseMessage mockedMessage = MakeMockedMessage(responseHeaders, HttpStatusCode.OK, mockedContent);

_mockHttp.When(_testUrl + "entities").Respond(req => mockedMessage);

EntitiesResponse response = _rosetteApi.Entity("Toyota");

Assert.AreEqual(expected, response);

Assert.AreEqual(expected.Entities[0].PermID, response.Entities[0].PermID);

Assert.AreEqual(expected.Entities[0].DBpediaType, response.Entities[0].DBpediaType);

Assert.AreEqual(expected.Entities[0].DBpediaTypes, response.Entities[0].DBpediaTypes);

}

[Test]

public void Entity_Content_Test() {

_mockHttp.When(_testUrl + "entities")

.Respond(HttpStatusCode.OK, "application/json", "{'response': 'OK'}");

var response = _rosetteApi.Entity("content");

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

[Test]

public void Entity_Dict_Test() {

_mockHttp.When(_testUrl + "entities")

.Respond(HttpStatusCode.OK, "application/json", "{'response': 'OK'}");

var response = _rosetteApi.Entity(new Dictionary<object, object>() { { "contentUri", "contentUrl" } });

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

[Test]

public void Entity_File_Test() {

_mockHttp.When(_testUrl + "entities")

.Respond("application/json", "{'response': 'OK'}");

RosetteFile f = new RosetteFile(_tmpFile);

var response = _rosetteApi.Entity(f);

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

[Test]

public void EntityIDLinkNullOnSetToNull()

{

EntityID eid = new EntityID(null);

Assert.AreEqual(null, eid.GetWikipedaURL());

}

//------------------------- Event ----------------------------------------

[Test]

public void EventTestFull()

{

Init();

RosetteEvent e0 = new RosetteEvent("DATA-1275-Meet-Travel.TRAVEL", new List<EventMention>() {

new EventMention(new List<EventRole> { new EventRole("key", "E1", "travel", null, null, null, 15, 21) },

"Negative", null, new List<NegationCue> { new NegationCue("not", 11, 14) }, 15, 21) }, 0.3333333333333333, "test");

List<RosetteEvent> events = new List<RosetteEvent>() { e0 };

string headersAsString = " { \"Content-Type\": \"application/json\", \"Date\": \"Thu, 11 Aug 2016 15:47:32 GMT\", \"Server\": \"openresty\", \"Strict-Transport-Security\": \"max-age=63072000; includeSubdomains; preload\", \"x-rosetteapi-app-id\": \"1409611723442\", \"x-rosetteapi-concurrency\": \"50\", \"x-rosetteapi-request-id\": \"d4176692-4f14-42d7-8c26-4b2d8f7ff049\", \"Content-Length\": \"72\", \"Connection\": \"Close\" }";

Dictionary<string, string> responseHeaders = new JavaScriptSerializer().Deserialize<Dictionary<string, string>>(headersAsString);

Dictionary<string, object> content = new Dictionary<string, object> {

{ "events", events }

};

EventsResponse expected = new EventsResponse(events, responseHeaders, content, null);

String mockedContent = expected.ContentToString();

HttpResponseMessage mockedMessage = MakeMockedMessage(responseHeaders, HttpStatusCode.OK, mockedContent);

_mockHttp.When(_testUrl + "events").Respond(req => mockedMessage);

_rosetteApi.SetOption("negation", "BOTH");

EventsResponse response = _rosetteApi.Event("Vivian went to Moscow.");

Assert.AreEqual(expected, response);

}

[Test]

public void Event_Content_Test()

{

_mockHttp.When(_testUrl + "events")

.Respond(HttpStatusCode.OK, "application/json", "{'response': 'OK'}");

var response = _rosetteApi.Event("content");

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

[Test]

public void Event_Dict_Test()

{

_mockHttp.When(_testUrl + "events")

.Respond(HttpStatusCode.OK, "application/json", "{'response': 'OK'}");

var response = _rosetteApi.Event(new Dictionary<object, object>() { { "contentUri", "contentUrl" } });

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

[Test]

public void Event_File_Test()

{

_mockHttp.When(_testUrl + "events")

.Respond("application/json", "{'response': 'OK'}");

RosetteFile f = new RosetteFile(_tmpFile);

var response = _rosetteApi.Event(f);

# pragma warning disable 618

Assert.AreEqual(response.Content["response"], "OK");

# pragma warning restore 618

}

//------------------------- Language ----------------------------------------

[Test]

public void LanguageTestFull()

{

Init();

LanguageDetection lang0 = new LanguageDetection("spa", (decimal)0.38719602327387076);

LanguageDetection lang1 = new LanguageDetection("eng", (decimal)0.32699986625091865);

LanguageDetection lang2 = new LanguageDetection("por", (decimal)0.05569054210624943);

LanguageDetection lang3 = new LanguageDetection("deu", (decimal)0.030069489878380328);

LanguageDetection lang4 = new LanguageDetection("zho", (decimal)0.23572849069656435);