public void RecordMatcherRespectsVolatiledQueryParameters(string requestUri, string entryUri, bool includeVolatile, bool shouldMatch)
{
var matcher = new RecordMatcher();
if (includeVolatile)
{
matcher.VolatileQueryParameters.Add("VolatileParam1");
matcher.VolatileQueryParameters.Add("VolatileParam2");
}
var mockRequest = new RecordEntry()
{
RequestUri = requestUri,
RequestMethod = RequestMethod.Put,
};
RecordEntry[] entries = new[]
{
new RecordEntry()
{
RequestUri = entryUri,
RequestMethod = RequestMethod.Put
}
};
if (shouldMatch)
{
Assert.NotNull(matcher.FindMatch(mockRequest, entries));
}
else
{
Assert.Throws <TestRecordingMismatchException>(() => matcher.FindMatch(mockRequest, entries));
}
}
/// <summary>
/// Creates a new SearchTestBase instance.
/// </summary>
/// <param name="async">
/// When false, we'll rewrite our tests methods to call the sync
/// versions of async APIs.
/// </param>
/// <param name="serviceVersion">
/// Version of the REST API to test against.
/// </param>
/// <param name="mode">
/// Whether to run in Playback, Record, or Live mode. The default
/// value is pulled from the AZURE_TEST_MODE environment variable.
/// </param>
public SearchTestBase(bool async, SearchClientOptions.ServiceVersion serviceVersion, RecordedTestMode?mode = null)
: base(async, mode ?? RecordedTestUtilities.GetModeFromEnvironment())
{
ServiceVersion = serviceVersion;
Sanitizer = new SearchRecordedTestSanitizer();
Matcher = new RecordMatcher(compareBodies: false);
}
public KeyResolverLiveTests(bool isAsync, KeyClientOptions.ServiceVersion serviceVersion)
: base(isAsync, serviceVersion, null /* RecordedTestMode.Record /* to re-record */)
{
_serviceVersion = serviceVersion;
// TODO: https://github.com/Azure/azure-sdk-for-net/issues/11634
Matcher = new RecordMatcher(compareBodies: false);
}
public void GenStringSanitizerQuietExitForAllHttpComponents()
{
var session = TestHelpers.LoadRecordSession("Test.RecordEntries/post_delete_get_content.json");
var untouchedSession = TestHelpers.LoadRecordSession("Test.RecordEntries/post_delete_get_content.json");
var targetString = ".*";
var replacementString = "<thistablehasbeenreplaced!>";
var targetEntry = session.Session.Entries[0];
var targetUntouchedEntry = untouchedSession.Session.Entries[0];
var matcher = new RecordMatcher();
var sanitizer = new GeneralStringSanitizer(targetString, replacementString);
session.Session.Sanitize(sanitizer);
var resultRequestBody = Encoding.UTF8.GetString(targetEntry.Request.Body);
var resultResponseBody = Encoding.UTF8.GetString(targetEntry.Response.Body);
var resultLocation = targetEntry.Response.Headers["Location"].First().ToString();
Assert.DoesNotContain(targetString, resultRequestBody);
Assert.DoesNotContain(targetString, resultResponseBody);
Assert.DoesNotContain(targetString, resultLocation);
Assert.Equal(0, matcher.CompareHeaderDictionaries(targetUntouchedEntry.Request.Headers, targetEntry.Request.Headers, new HashSet <string>(), new HashSet <string>()));
Assert.Equal(0, matcher.CompareHeaderDictionaries(targetUntouchedEntry.Response.Headers, targetEntry.Response.Headers, new HashSet <string>(), new HashSet <string>()));
Assert.Equal(0, matcher.CompareBodies(targetUntouchedEntry.Request.Body, targetEntry.Request.Body));
Assert.Equal(0, matcher.CompareBodies(targetUntouchedEntry.Response.Body, targetEntry.Response.Body));
Assert.Equal(targetUntouchedEntry.RequestUri, targetEntry.RequestUri);
}
public BlobBatchClientTests(bool async, BlobClientOptions.ServiceVersion serviceVersion)
: base(async, serviceVersion, null /* RecordedTestMode.Record /* to re-record */)
{
// Batch delimiters are random so disable body comparison
Matcher = new RecordMatcher(compareBodies: false);
Sanitizer = new BatchStorageRecordedTestSanitizer();
}
public CryptographyClientLiveTests(bool isAsync, KeyClientOptions.ServiceVersion serviceVersion)
: base(isAsync, serviceVersion)
{
_serviceVersion = serviceVersion;
// TODO: https://github.com/Azure/azure-sdk-for-net/issues/11634
Matcher = new RecordMatcher(compareBodies: false);
}
public void RecordMatcherIgnoresIgnoredHeaders()
{
var matcher = new RecordMatcher(new RecordedTestSanitizer());
MockRequest mockRequest = new MockRequest
{
Method = RequestMethod.Put
};
mockRequest.UriBuilder.Uri = new Uri("http://localhost");
RecordEntry[] entries = new[]
{
new RecordEntry()
{
RequestUri = "http://localhost",
RequestMethod = RequestMethod.Put,
RequestHeaders =
{
{ "Request-Id", new[] { "Non-Random value" } },
}
}
};
Assert.NotNull(matcher.FindMatch(mockRequest, entries));
}
public void RecordMatcherIgnoresIgnoredHeaders()
{
var matcher = new RecordMatcher();
var mockRequest = new RecordEntry()
{
RequestUri = "http://localhost",
RequestMethod = RequestMethod.Put,
};
RecordEntry[] entries = new[]
{
new RecordEntry()
{
RequestUri = "http://localhost",
RequestMethod = RequestMethod.Put,
Request =
{
Headers =
{
{ "Request-Id", new[] { "Non-Random value" } },
}
}
}
};
Assert.NotNull(matcher.FindMatch(mockRequest, entries));
}
protected KeyClientLiveTests(bool isAsync, KeyClientOptions.ServiceVersion serviceVersion, RecordedTestMode?mode)
: base(isAsync, serviceVersion, mode)
{
_serviceVersion = serviceVersion;
// TODO: https://github.com/Azure/azure-sdk-for-net/issues/11634
Matcher = new RecordMatcher(compareBodies: false);
}
protected ConversationAnalysisTestBase(bool isAsync, ConversationAnalysisClientOptions.ServiceVersion serviceVersion, RecordedTestMode?mode)
: base(isAsync, mode)
{
// TODO: Compare bodies again when https://github.com/Azure/azure-sdk-for-net/issues/22219 is resolved.
Matcher = new RecordMatcher(compareBodies: false);
Sanitizer = new ConversationAnalysisRecordedTestSanitizer();
ServiceVersion = serviceVersion;
}
public void SetMatcherForRecording(string recordingId, RecordMatcher matcher)
{
if (!PlaybackSessions.TryGetValue(recordingId, out var session))
{
throw new HttpException(HttpStatusCode.BadRequest, $"{recordingId} is not an active playback session. Check the value being passed and try again.");
}
session.CustomMatcher = matcher;
}
public void RecordMatcherThrowsExceptionsWithDetails()
{
var matcher = new RecordMatcher();
var requestEntry = new RecordEntry()
{
RequestUri = "http://localhost/",
RequestMethod = RequestMethod.Head,
Request =
{
Headers =
{
{ "Content-Length", new[] { "41" } },
{ "Some-Header", new[] { "Random value" } },
{ "Some-Other-Header", new[] { "V" } }
},
Body = Encoding.UTF8.GetBytes("This is request body, it's nice and long.")
}
};
RecordEntry[] entries = new[]
{
new RecordEntry()
{
RequestUri = "http://remote-host",
RequestMethod = RequestMethod.Put,
Request =
{
Headers =
{
{ "Content-Length", new[] { "41" } },
{ "Some-Header", new[] { "Non-Random value" } },
{ "Extra-Header", new[] { "Extra-Value" } }
},
Body = Encoding.UTF8.GetBytes("This is request body, it's nice and long but it also doesn't match.")
}
}
};
InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() => matcher.FindMatch(requestEntry, entries));
Assert.AreEqual(
"Unable to find a record for the request HEAD http://localhost/" + Environment.NewLine +
"Method doesn't match, request <HEAD> record <PUT>" + Environment.NewLine +
"Uri doesn't match:" + Environment.NewLine +
" request <http://localhost/>" + Environment.NewLine +
" record <http://remote-host>" + Environment.NewLine +
"Header differences:" + Environment.NewLine +
" <Some-Header> values differ, request <Random value>, record <Non-Random value>" + Environment.NewLine +
" <Some-Other-Header> is absent in record, value <V>" + Environment.NewLine +
" <Extra-Header> is absent in request, value <Extra-Value>" + Environment.NewLine +
"Body differences:" + Environment.NewLine +
"Request and response bodies do not match at index 40:" + Environment.NewLine +
" request: \"e and long.\"" + Environment.NewLine +
" record: \"e and long but it also doesn't\"" + Environment.NewLine,
exception.Message);
}
public AzureClientAttributeFunctionalTests(bool isAsync) : base(isAsync)
{
Matcher = new RecordMatcher()
{
IgnoredQueryParameters =
{
// Ignore KeyVault client API Version when matching
"api-version"
}
};
}
public void RecordMatcheRequiresPresenceOfIgnoredHeaders()
{
var matcher = new RecordMatcher();
var mockRequest = new RecordEntry()
{
RequestUri = "http://localhost",
RequestMethod = RequestMethod.Put,
Request =
{
// Request-Id and TraceParent are ignored until we can
// re-record all old tests.
Headers =
{
{ "Request-Id", new[] { "Some Random value" } },
{ "Date", new[] { "Fri, 06 Nov 2020 02:42:26 GMT" } },
{ "x-ms-date", new[] { "Fri, 06 Nov 2020 02:42:26 GMT" } },
}
}
};
RecordEntry[] entries = new[]
{
new RecordEntry()
{
RequestUri = "http://localhost",
RequestMethod = RequestMethod.Put,
Request =
{
Headers =
{
{ "x-ms-client-request-id", new[] { "some random request id" } },
{ "User-Agent", new[] { "some random sdk" } },
{ "traceparent", new[] { "some random traceparent" } }
}
}
}
};
TestRecordingMismatchException exception = Assert.Throws <TestRecordingMismatchException>(() => matcher.FindMatch(mockRequest, entries));
Assert.Equal(
"Unable to find a record for the request PUT http://localhost" + Environment.NewLine +
"Header differences:" + Environment.NewLine +
" <Date> is absent in record, value <Fri, 06 Nov 2020 02:42:26 GMT>" + Environment.NewLine +
" <x-ms-date> is absent in record, value <Fri, 06 Nov 2020 02:42:26 GMT>" + Environment.NewLine +
" <User-Agent> is absent in request, value <some random sdk>" + Environment.NewLine +
" <x-ms-client-request-id> is absent in request, value <some random request id>" + Environment.NewLine +
"Body differences:" + Environment.NewLine,
exception.Message);
}
public void UriStringSanitizerQuietlyExits(string targetValue, string replacementValue, string targetFile)
{
var session = TestHelpers.LoadRecordSession(targetFile);
var untouchedSession = TestHelpers.LoadRecordSession(targetFile);
var targetEntry = session.Session.Entries[0];
var targetUntouchedEntry = untouchedSession.Session.Entries[0];
var matcher = new RecordMatcher();
var sanitizer = new UriStringSanitizer(targetValue, replacementValue);
session.Session.Sanitize(sanitizer);
Assert.Equal(targetUntouchedEntry.RequestUri, targetEntry.RequestUri);
}
public void HeaderStringSanitizerQuietlyExits(string targetKey, string targetValue, string replacementValue, string recordingFile)
{
var session = TestHelpers.LoadRecordSession(recordingFile);
var untouchedSession = TestHelpers.LoadRecordSession(recordingFile);
var targetUntouchedEntry = untouchedSession.Session.Entries[0];
var targetEntry = session.Session.Entries[0];
var matcher = new RecordMatcher();
var sanitizer = new HeaderStringSanitizer(targetKey, targetValue, value: replacementValue);
session.Session.Sanitize(sanitizer);
Assert.Equal(0, matcher.CompareHeaderDictionaries(targetUntouchedEntry.Request.Headers, targetEntry.Request.Headers, new HashSet <string>(), new HashSet <string>()));
Assert.Equal(0, matcher.CompareHeaderDictionaries(targetUntouchedEntry.Response.Headers, targetEntry.Response.Headers, new HashSet <string>(), new HashSet <string>()));
}
public void RecordMatcherIgnoresValuesOfIgnoredHeaders()
{
var matcher = new RecordMatcher();
var mockRequest = new RecordEntry()
{
RequestUri = "http://localhost",
RequestMethod = RequestMethod.Put,
Request =
{
Headers =
{
{ "Request-Id", new[] { "Non-Random value" } },
{ "Date", new[] { "Fri, 05 Nov 2020 02:42:26 GMT" } },
{ "x-ms-date", new[] { "Fri, 05 Nov 2020 02:42:26 GMT" } },
{ "x-ms-client-request-id", new[] { "non random request id" } },
{ "x-ms-client-id", new[] { "non random client id" } },
{ "User-Agent", new[] { "non random sdk" } },
{ "traceparent", new[] { "non random traceparent" } }
}
}
};
RecordEntry[] entries = new[]
{
new RecordEntry()
{
RequestUri = "http://localhost",
RequestMethod = RequestMethod.Put,
Request =
{
Headers =
{
{ "Request-Id", new[] { "Some Random value" } },
{ "Date", new[] { "Fri, 06 Nov 2020 02:42:26 GMT" } },
{ "x-ms-date", new[] { "Fri, 06 Nov 2020 02:42:26 GMT" } },
{ "x-ms-client-request-id", new[] { "some random request id" } },
{ "x-ms-client-id", new[] { "some random client id" } },
{ "User-Agent", new[] { "some random sdk" } },
{ "traceparent", new[] { "some random traceparent" } }
}
}
}
};
Assert.NotNull(matcher.FindMatch(mockRequest, entries));
}
public void BodyStringSanitizerQuietlyExits(string targetValue, string replacementValue, string recordingFile)
{
var session = TestHelpers.LoadRecordSession(recordingFile);
var untouchedSession = TestHelpers.LoadRecordSession(recordingFile);
var targetEntry = session.Session.Entries[0];
var originalBodyValue = Encoding.UTF8.GetString(targetEntry.Request.Body);
var targetUntouchedEntry = untouchedSession.Session.Entries[0];
var matcher = new RecordMatcher();
var sanitizer = new BodyStringSanitizer(targetValue, value: replacementValue);
session.Session.Sanitize(sanitizer);
var resultBodyValue = Encoding.UTF8.GetString(targetEntry.Request.Body);
Assert.Equal(0, matcher.CompareBodies(targetUntouchedEntry.Request.Body, targetEntry.Request.Body));
Assert.Equal(0, matcher.CompareBodies(targetUntouchedEntry.Response.Body, targetEntry.Response.Body));
}
public async Task SetMatcher()
{
await DebugLogger.LogRequestDetailsAsync(_logger, Request);
var mName = RecordingHandler.GetHeader(Request, "x-abstraction-identifier");
var recordingId = RecordingHandler.GetHeader(Request, "x-recording-id", allowNulls: true);
RecordMatcher m = (RecordMatcher)GetMatcher(mName, await HttpRequestInteractions.GetBody(Request));
if (recordingId != null)
{
_recordingHandler.SetMatcherForRecording(recordingId, m);
}
else
{
_recordingHandler.Matcher = m;
}
}
public void RecordMatcherThrowsExceptionsWithDetails()
{
var matcher = new RecordMatcher(new RecordedTestSanitizer());
MockRequest mockRequest = new MockRequest
{
Method = RequestMethod.Head
};
mockRequest.Uri.Reset(new Uri("http://localhost"));
mockRequest.Headers.Add("Some-Header", "Random value");
mockRequest.Headers.Add("Some-Other-Header", "V");
RecordEntry[] entries = new[]
{
new RecordEntry()
{
RequestUri = "http://remote-host",
RequestMethod = RequestMethod.Put,
Request =
{
Headers =
{
{ "Some-Header", new[] { "Non-Random value" } },
{ "Extra-Header", new[] { "Extra-Value" } }
}
}
}
};
InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() => matcher.FindMatch(mockRequest, entries));
Assert.AreEqual(
"Unable to find a record for the request HEAD http://localhost/" + Environment.NewLine +
"Method doesn't match, request <HEAD> record <PUT>" + Environment.NewLine +
"Uri doesn't match:" + Environment.NewLine +
" request <http://localhost/>" + Environment.NewLine +
" record <http://remote-host>" + Environment.NewLine +
"Header differences:" + Environment.NewLine +
" <Some-Header> values differ, request <Random value>, record <Non-Random value>" + Environment.NewLine +
" <Some-Other-Header> is absent in record, value <V>" + Environment.NewLine +
" <Extra-Header> is absent in request, value <Extra-Value>" + Environment.NewLine,
exception.Message);
}
public void RecordMatcherThrowsExceptionsWhenNoRecordsLeft()
{
var matcher = new RecordMatcher();
var mockRequest = new RecordEntry()
{
RequestUri = "http://localhost/",
RequestMethod = RequestMethod.Head
};
RecordEntry[] entries = { };
InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() => matcher.FindMatch(mockRequest, entries));
Assert.AreEqual(
"Unable to find a record for the request HEAD http://localhost/" + Environment.NewLine +
"No records to match." + Environment.NewLine,
exception.Message);
}
public void UriStringSanitizerApplies(string targetValue, string replacementValue, string recordingFile)
{
var session = TestHelpers.LoadRecordSession(recordingFile);
var untouchedSession = TestHelpers.LoadRecordSession(recordingFile);
var targetEntry = session.Session.Entries[0];
var targetUntouchedEntry = untouchedSession.Session.Entries[0];
var matcher = new RecordMatcher();
var sanitizer = new UriStringSanitizer(targetValue, replacementValue);
session.Session.Sanitize(sanitizer);
var originalUriValue = targetUntouchedEntry.RequestUri.ToString();
var resultUriValue = targetEntry.RequestUri.ToString();
Assert.NotEqual(originalUriValue, resultUriValue);
Assert.Contains(replacementValue, resultUriValue);
Assert.DoesNotContain(targetValue, resultUriValue);
}
public void RecordMatcherThrowsExceptionsWhenNoRecordsLeft()
{
var matcher = new RecordMatcher(new RecordedTestSanitizer());
MockRequest mockRequest = new MockRequest();
mockRequest.Method = RequestMethod.Head;
mockRequest.UriBuilder.Uri = new Uri("http://localhost");
mockRequest.Headers.Add("Some-Header", "Random value");
mockRequest.Headers.Add("Some-Other-Header", "V");
RecordEntry[] entries = {};
InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() => matcher.FindMatch(mockRequest, entries));
Assert.AreEqual(
"Unable to find a record for the request HEAD http://localhost/" + Environment.NewLine +
"No records to match." + Environment.NewLine,
exception.Message);
}
public void BodyNormalizationWorksWhenMatching(string body, string contentType)
{
byte[] bodyBytes = Encoding.UTF8.GetBytes(body);
var session = new RecordSession();
session.Variables["a"] = "value a";
session.Variables["b"] = "value b";
RecordEntry recordEntry = new RecordEntry();
recordEntry.Request.Headers.Add("Content-Type", new[] { contentType });
recordEntry.Request.Headers.Add("Other-Header", new[] { "multi", "value" });
recordEntry.Request.Body = bodyBytes;
recordEntry.RequestUri = "http://localhost/";
recordEntry.RequestMethod = RequestMethod.Delete;
recordEntry.Response.Headers.Add("Content-Type", new[] { contentType });
recordEntry.Response.Headers.Add("Other-Response-Header", new[] { "multi", "value" });
recordEntry.Response.Body = bodyBytes;
recordEntry.StatusCode = 202;
session.Entries.Add(recordEntry);
var arrayBufferWriter = new ArrayBufferWriter <byte>();
using var jsonWriter = new Utf8JsonWriter(arrayBufferWriter, new JsonWriterOptions()
{
Indented = true
});
session.Serialize(jsonWriter);
jsonWriter.Flush();
var document = JsonDocument.Parse(arrayBufferWriter.WrittenMemory);
var deserializedSession = RecordSession.Deserialize(document.RootElement);
var matcher = new RecordMatcher();
Assert.NotNull(deserializedSession.Lookup(recordEntry, matcher, new[] { new RecordedTestSanitizer() }));
}
public void RecordMatcherIgnoresLegacyExcludedHeaders()
{
var matcher = new RecordMatcher
{
ExcludeHeaders = { "some header", "another" }
};
var mockRequest = new RecordEntry()
{
RequestUri = "http://localhost",
RequestMethod = RequestMethod.Put,
Request =
{
Headers =
{
{ "some header", new[] { "Non-Random value" } },
}
}
};
RecordEntry[] entries = new[]
{
new RecordEntry()
{
RequestUri = "http://localhost",
RequestMethod = RequestMethod.Put,
Request =
{
Headers =
{
{ "another", new[] { "Some Random value" } },
}
}
}
};
Assert.NotNull(matcher.FindMatch(mockRequest, entries));
}
public void SpecialHeadersNormalizedForMatching(string name)
{
// Use HttpClientTransport as it does header normalization
var originalRequest = new HttpClientTransport().CreateRequest();
originalRequest.Method = RequestMethod.Get;
originalRequest.Uri.Reset(new Uri("http://localhost"));
originalRequest.Headers.Add(name, "application/json;odata=nometadata");
originalRequest.Headers.Add("Date", "This should be ignored");
var playbackRequest = new MockTransport().CreateRequest();
playbackRequest.Method = RequestMethod.Get;
playbackRequest.Uri.Reset(new Uri("http://localhost"));
playbackRequest.Headers.Add(name, "application/json;odata=nometadata");
playbackRequest.Headers.Add("Date", "It doesn't match");
var matcher = new RecordMatcher();
var requestEntry = RecordTransport.CreateEntry(originalRequest, null);
var entry = RecordTransport.CreateEntry(originalRequest, new MockResponse(200));
Assert.NotNull(matcher.FindMatch(requestEntry, new[] { entry }));
}
/// <summary>
/// Checks if a table is sorted
/// </summary>
/// <param name="T">The table to check</param>
/// <param name="Columns">The desied sort order</param>
/// <returns>the first instance that a record is out of order; if the table is sorted, returns a record not found key </returns>
public static RecordKey CheckSort(Table T, Key Columns)
{
if (T.RecordCount < 2)
{
return(RecordKey.RecordNotFound);
}
RecordReader rs = T.OpenReader();
RecordMatcher matcher = new RecordMatcher(Columns);
Record First = rs.ReadNext();
while (rs.CanAdvance)
{
// We want First <= Second
Record Second = rs.ReadNext();
int check = matcher.Compare(First, Second);
if (check > 0)
{
return(rs.PositionKey);
}
}
return(RecordKey.RecordNotFound);
}
public TextAnalyticsClientLiveTests(bool isAsync) : base(isAsync)
{
Sanitizer = new TextAnalyticsRecordedTestSanitizer();
Matcher = new RecordMatcher(Sanitizer);
}
public PersonalizerTestBase(bool isAsync) : base(isAsync)
{
// TODO: Compare bodies again when https://github.com/Azure/azure-sdk-for-net/issues/22219 is resolved.
Matcher = new RecordMatcher(compareBodies: false);
Sanitizer = new PersonalizerRecordedTestSanitizer();
}
public ConfigurationLiveTests(bool isAsync) : base(isAsync)
{
Sanitizer = new ConfigurationRecordedTestSanitizer();
Matcher = new RecordMatcher(Sanitizer);
}
