private void AssertDirectoryStructure(IDirectoryStructure expected, IDirectoryStructure actual, string path)
{
// Request Info/Methods
if (expected.RequestInfo is null)
{
Assert.True(actual.RequestInfo is null, $"RequestInfo should be null on {path}");
}
else
{
AssertRequestInfo(expected.RequestInfo, actual.RequestInfo, path);
}
// Subdirectories
IEnumerator <string> expectedDirectoriesEnumerator = expected.DirectoryNames.GetEnumerator();
IEnumerator <string> actualDirectoriesEnumerator = actual.DirectoryNames.GetEnumerator();
int directoryIndex = 0;
while (expectedDirectoriesEnumerator.MoveNext())
{
Assert.True(actualDirectoriesEnumerator.MoveNext(), $"Missing subdirectory in {path}: {expectedDirectoriesEnumerator.Current}");
Assert.True(string.Equals(expectedDirectoriesEnumerator.Current, actualDirectoriesEnumerator.Current, System.StringComparison.Ordinal), $"Expected Directory \"{expectedDirectoriesEnumerator.Current}\" does not match Actual Directory \"{actualDirectoriesEnumerator.Current}\" at index {directoryIndex} in {path}.");
AssertDirectoryStructure(expected.TraverseTo(expectedDirectoriesEnumerator.Current), actual.TraverseTo(actualDirectoriesEnumerator.Current), $"{path}{expectedDirectoriesEnumerator.Current}/");
directoryIndex++;
}
Assert.False(actualDirectoriesEnumerator.MoveNext(), $"Extra subdirectory in {path}: {actualDirectoriesEnumerator.Current}");
}
public void ReadMetadata_WithSpecifiedMethodName_ReturnsApiDefinitionWithCorrectNumberOfRequestMethods(string method, bool shouldHaveRequest)
{
string json = @"{
""openapi"": ""3.0.0"",
""paths"": {
""/pets"": {
""" + method + @""": """"
}
}
}";
JObject jobject = JObject.Parse(json);
OpenApiV3ApiDefinitionReader openApiV3ApiDefinitionReader = new OpenApiV3ApiDefinitionReader();
ApiDefinition apiDefinition = openApiV3ApiDefinitionReader.ReadDefinition(jobject, null);
Assert.NotNull(apiDefinition?.DirectoryStructure);
Assert.Single(apiDefinition.DirectoryStructure.DirectoryNames);
Assert.Equal("pets", apiDefinition.DirectoryStructure.DirectoryNames.Single());
IDirectoryStructure subDirectory = apiDefinition.DirectoryStructure.TraverseTo("/pets");
if (shouldHaveRequest)
{
Assert.Single(subDirectory.RequestInfo.Methods);
Assert.Contains(method, subDirectory.RequestInfo.Methods, StringComparer.Ordinal);
}
else
{
Assert.Null(subDirectory.RequestInfo);
}
}
public IEnumerable <string> GetApplicableContentTypes(string method, string path)
{
if (BaseAddress is null && !Uri.IsWellFormedUriString(path, UriKind.Absolute))
{
return(null);
}
Uri effectivePath = GetEffectivePath(path);
string rootRelativePath = effectivePath.LocalPath.Substring(BaseAddress.LocalPath.Length).TrimStart('/');
IDirectoryStructure structure = Structure?.TraverseTo(rootRelativePath);
IReadOnlyDictionary <string, IReadOnlyList <string> > contentTypesByMethod = structure?.RequestInfo?.ContentTypesByMethod;
if (contentTypesByMethod != null)
{
if (method is null)
{
return(contentTypesByMethod.Values.SelectMany(x => x).Distinct(StringComparer.OrdinalIgnoreCase));
}
if (contentTypesByMethod.TryGetValue(method, out IReadOnlyList <string> contentTypes))
{
return(contentTypes);
}
}
return(null);
}
public void ReadMetadata_WithNoResponses_ReturnsApiDefinition()
{
string json = @"{
""openapi"": ""3.0.0"",
""paths"": {
""/pets"": {
""post"": {
""summary"": ""Create a pet"",
""operationId"": ""createPets"",
""requestBody"": {
""content"": {
}
}
}
}
}
}";
OpenApiDotNetApiDefinitionReader openApiV3ApiDefinitionReader = new OpenApiDotNetApiDefinitionReader();
ApiDefinition apiDefinition = openApiV3ApiDefinitionReader.ReadDefinition(json, null);
Assert.NotNull(apiDefinition?.DirectoryStructure);
Assert.Single(apiDefinition.DirectoryStructure.DirectoryNames);
Assert.Equal("pets", apiDefinition.DirectoryStructure.DirectoryNames.Single());
IDirectoryStructure subDirectory = apiDefinition.DirectoryStructure.TraverseTo("/pets");
Assert.Single(subDirectory.RequestInfo.Methods);
Assert.Contains("Post", subDirectory.RequestInfo.Methods, StringComparer.Ordinal);
}
public async Task ExecuteAsync_WithChildDirectories_SetsHttpStateSwaggerStructureWithChildDirectorStuctureInfo()
{
string response = @"{
""swagger"": ""2.0"",
""paths"": {
""/api/Employees"": {
""get"": {
""tags"": [ ""Employees"" ],
""operationId"": ""GetEmployee"",
""consumes"": [],
""produces"": [ ""text/plain"", ""application/json"", ""text/json"" ],
""parameters"": [],
""responses"": {
""200"": {
""description"": ""Success"",
""schema"": {
""uniqueItems"": false,
""type"": ""array""
}
}
}
}
},
""/api/Values"": {
""post"": {
""tags"": [ ""Values"" ],
""operationId"": ""Post"",
""consumes"": [ ""application/json-patch+json"", ""application/json"", ""text/json"", ""application/*+json"" ],
""produces"": [],
""parameters"": [
{
""name"": ""value"",
""in"": ""body"",
""required"": false,
""schema"": { ""type"": ""string"" }
}
],
""responses"": { ""200"": { ""description"": ""Success"" } }
}
}
}
}";
string baseAddress = "http://localhost:5050/somePath";
string parseResultSections = "set swagger " + baseAddress;
IDirectoryStructure directoryStructure = await GetDirectoryStructure(response, parseResultSections, baseAddress).ConfigureAwait(false);
List <string> directoryNames = directoryStructure.DirectoryNames.ToList();
string expectedDirectoryName = "api";
Assert.Single(directoryNames);
Assert.Equal(expectedDirectoryName, directoryNames.First());
IDirectoryStructure childDirectoryStructure = directoryStructure.GetChildDirectory(expectedDirectoryName);
List <string> childDirectoryNames = childDirectoryStructure.DirectoryNames.ToList();
Assert.Equal(2, childDirectoryNames.Count);
Assert.Equal("Employees", childDirectoryNames.First());
Assert.Equal("Values", childDirectoryNames.ElementAt(1));
}
public string GetExampleBody(string path, string contentType, string method)
{
Uri effectivePath = GetEffectivePath(path);
string rootRelativePath = effectivePath.LocalPath.Substring(BaseAddress.LocalPath.Length).TrimStart('/');
IDirectoryStructure structure = SwaggerStructure?.TraverseTo(rootRelativePath);
return(structure?.RequestInfo?.GetRequestBodyForContentType(contentType, method));
}
private string GetExampleBody(string path, ref string contentType, string method, HttpState httpState)
{
Uri effectivePath = httpState.GetEffectivePath(path);
string rootRelativePath = effectivePath.LocalPath.Substring(httpState.BaseAddress.LocalPath.Length).TrimStart('/');
IDirectoryStructure structure = httpState.Structure?.TraverseTo(rootRelativePath);
return(structure?.RequestInfo?.GetRequestBodyForContentType(ref contentType, method));
}
public static IDirectoryStructure TraverseTo(this IDirectoryStructure structure, string path)
{
structure = structure ?? throw new ArgumentNullException(nameof(structure));
path = path ?? throw new ArgumentNullException(nameof(path));
string[] parts = path.Replace('\\', '/').Split('/');
return(structure.TraverseTo(parts));
}
public void ReadMetadata_WithValidInput_ReturnsApiDefinition()
{
string json = @"{
""openapi"": ""3.0.0"",
""paths"": {
""/pets"": {
""get"": {
""summary"": ""List all pets"",
""operationId"": ""listPets"",
""parameters"": [
{
""name"": ""limit"",
""in"": ""query"",
""required"": false,
""schema"": {
""type"": ""integer"",
""format"": ""int32""
}
}
],
""responses"": {
""200"": {
""description"": ""An paged array of pets""
}
}
},
""post"": {
""summary"": ""Create a pet"",
""operationId"": ""createPets"",
""responses"": {
""201"": {
""description"": ""Null response""
}
},
""requestBody"": {
""content"": {
}
}
}
}
}
}";
OpenApiDotNetApiDefinitionReader openApiV3ApiDefinitionReader = new OpenApiDotNetApiDefinitionReader();
ApiDefinition apiDefinition = openApiV3ApiDefinitionReader.ReadDefinition(json, null);
Assert.NotNull(apiDefinition?.DirectoryStructure);
Assert.Single(apiDefinition.DirectoryStructure.DirectoryNames);
Assert.Equal("pets", apiDefinition.DirectoryStructure.DirectoryNames.Single());
IDirectoryStructure subDirectory = apiDefinition.DirectoryStructure.TraverseTo("/pets");
Assert.Equal(2, subDirectory.RequestInfo.Methods.Count);
Assert.Contains("Get", subDirectory.RequestInfo.Methods, StringComparer.Ordinal);
Assert.Contains("Post", subDirectory.RequestInfo.Methods, StringComparer.Ordinal);
}
public async Task ExecuteAsync_WithRelativeUrlAndNoBaseAddress_DoesNotSetApiDefinition()
{
string swaggerAddress = "/swagger.json";
string baseAddress = null;
string parseResultSections = "set swagger " + swaggerAddress;
IDirectoryStructure directoryStructure = await GetDirectoryStructure(null, parseResultSections, null, baseAddress).ConfigureAwait(false);
Assert.Null(directoryStructure);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="IDirectoryStructure">A class which retrieve a folders and files from directories</param>
public CompareDirectoryStructure(IDirectoryStructure directoryStructure)
{
if (directoryStructure != null)
{
CompareDirectoriesContents(directoryStructure.GetDirectoriesContent());
}
else
{
throw new CustomException(Messages.TheClassDirectoryStructureIsNull);
}
}
public static IEnumerable <string> GetCompletions(HttpState programState, string normalCompletionString)
{
//If it's an absolute URI, nothing to suggest
if (Uri.IsWellFormedUriString(normalCompletionString, UriKind.Absolute))
{
return(null);
}
programState = programState ?? throw new ArgumentNullException(nameof(programState));
normalCompletionString = normalCompletionString ?? throw new ArgumentNullException(nameof(normalCompletionString));
if (programState.Structure is null)
{
return(null);
}
string path = normalCompletionString.Replace('\\', '/');
int searchFrom = normalCompletionString.Length - 1;
int lastSlash = path.LastIndexOf('/', searchFrom);
string prefix;
if (lastSlash < 0)
{
path = string.Empty;
prefix = normalCompletionString;
}
else
{
path = path.Substring(0, lastSlash + 1);
prefix = normalCompletionString.Substring(lastSlash + 1);
}
IDirectoryStructure s = programState.Structure.TraverseTo(programState.PathSections.Reverse()).TraverseTo(path);
if (s?.DirectoryNames == null)
{
return(null);
}
List <string> results = new List <string>();
foreach (string child in s.DirectoryNames)
{
if (child.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
{
results.Add(path + child);
}
}
return(results);
}
public void ReadMetadata_WithSpecifiedMethodName_ReturnsApiDefinitionWithCorrectNumberOfRequestMethods(string method, bool shouldHaveRequest)
{
// The method must be lowercase to be valid in the json
string methodForJson = method.ToLower();
string json = @"{
""openapi"": ""3.0.0"",
""info"": {
""title"": ""OpenAPI v3 Spec"",
""version"": ""v1""
},
""paths"": {
""/pets"": {
""" + methodForJson + @""": {
""summary"": ""Do something"",
""operationId"": ""doSomething"",
""responses"": {
""200"": {
""description"": ""Null response""
}
},
""requestBody"": {
""description"": ""A Request Body"",
""required"": false
}
}
}
}
}";
OpenApiDotNetApiDefinitionReader openApiV3ApiDefinitionReader = new OpenApiDotNetApiDefinitionReader();
ApiDefinition apiDefinition = openApiV3ApiDefinitionReader.ReadDefinition(json, null);
Assert.NotNull(apiDefinition?.DirectoryStructure);
Assert.Single(apiDefinition.DirectoryStructure.DirectoryNames);
Assert.Equal("pets", apiDefinition.DirectoryStructure.DirectoryNames.Single());
IDirectoryStructure subDirectory = apiDefinition.DirectoryStructure.TraverseTo("/pets");
if (shouldHaveRequest)
{
Assert.Single(subDirectory.RequestInfo.Methods);
Assert.Contains(method, subDirectory.RequestInfo.Methods, StringComparer.OrdinalIgnoreCase);
}
else
{
Assert.Null(subDirectory.RequestInfo);
}
}
public async Task ExecuteAsync_WithValidInput_CreatesDirectoryStructureForSwaggerEndpoint()
{
string response = @"{
""swagger"": ""2.0"",
""paths"": {
""/api"": {
""get"": {
""tags"": [ ""Employees"" ],
""operationId"": ""GetEmployee"",
""consumes"": [],
""produces"": [ ""text/plain"", ""application/json"", ""text/json"" ],
""parameters"": [],
""responses"": {
""200"": {
""description"": ""Success"",
""schema"": {
""uniqueItems"": false,
""type"": ""array""
}
}
}
}
}
}
}";
ArrangeInputs(parseResultSections: "set base \"https://localhost:44366/\"",
out MockedShellState shellState,
out HttpState httpState,
out ICoreParseResult parseResult,
responseContent: response,
baseAddress: "https://localhost:44366/swagger.json");
SetBaseCommand setBaseCommand = new SetBaseCommand();
await setBaseCommand.ExecuteAsync(shellState, httpState, parseResult, CancellationToken.None);
IDirectoryStructure directoryStructure = httpState.Structure;
List <string> directoryNames = directoryStructure.DirectoryNames.ToList();
string expectedDirectoryName = "api";
Assert.Single(directoryNames);
Assert.Equal(expectedDirectoryName, directoryNames.First());
IDirectoryStructure childDirectoryStructure = directoryStructure.GetChildDirectory(expectedDirectoryName);
Assert.Empty(childDirectoryStructure.DirectoryNames);
}
public IDirectoryStructure GetChildDirectory(string name)
{
if (_childDirectories.TryGetValue(name, out DirectoryStructure result))
{
return(result);
}
IDirectoryStructure parameterizedTarget = _childDirectories.FirstOrDefault(x => x.Key.StartsWith('{') && x.Key.EndsWith('}')).Value;
if (!(parameterizedTarget is null))
{
return(parameterizedTarget);
}
return(new DirectoryStructure(this));
}
protected override IEnumerable <string> GetArgumentSuggestionsForText(IShellState shellState, HttpState programState, ICoreParseResult parseResult, DefaultCommandInput <ICoreParseResult> commandInput, string normalCompletionString)
{
programState = programState ?? throw new ArgumentNullException(nameof(programState));
if (programState.Structure == null || programState.BaseAddress == null)
{
return(null);
}
//If it's an absolute URI, nothing to suggest
if (Uri.TryCreate(normalCompletionString, UriKind.Absolute, out Uri _))
{
return(null);
}
normalCompletionString = normalCompletionString ?? throw new ArgumentNullException(nameof(normalCompletionString));
string path = normalCompletionString.Replace('\\', '/');
int searchFrom = normalCompletionString.Length - 1;
int lastSlash = path.LastIndexOf('/', searchFrom);
string prefix;
if (lastSlash < 0)
{
path = string.Empty;
prefix = normalCompletionString;
}
else
{
path = path.Substring(0, lastSlash + 1);
prefix = normalCompletionString.Substring(lastSlash + 1);
}
IDirectoryStructure s = programState.Structure.TraverseTo(programState.PathSections.Reverse()).TraverseTo(path);
List <string> results = new List <string>();
foreach (string child in s.DirectoryNames)
{
if (child.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
{
results.Add(path + child);
}
}
return(results);
}
protected override Task ExecuteAsync(IShellState shellState, HttpState programState, DefaultCommandInput <ICoreParseResult> commandInput, ICoreParseResult parseResult, CancellationToken cancellationToken)
{
if (commandInput.Arguments.Count == 0 || string.IsNullOrEmpty(commandInput.Arguments[0]?.Text))
{
shellState.ConsoleManager.WriteLine($"/{string.Join("/", programState.PathSections.Reverse())}");
}
else
{
string[] parts = commandInput.Arguments[0].Text.Replace('\\', '/').Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (commandInput.Arguments[0].Text.StartsWith("/", StringComparison.Ordinal))
{
programState.PathSections.Clear();
}
foreach (string part in parts)
{
switch (part)
{
case ".":
break;
case "..":
if (programState.PathSections.Count > 0)
{
programState.PathSections.Pop();
}
break;
default:
programState.PathSections.Push(part);
break;
}
}
IDirectoryStructure s = programState.Structure.TraverseTo(programState.PathSections.Reverse());
string thisDirMethod = s.RequestInfo != null && s.RequestInfo.Methods.Count > 0
? "[" + string.Join("|", s.RequestInfo.Methods) + "]"
: "[]";
shellState.ConsoleManager.WriteLine($"/{string.Join("/", programState.PathSections.Reverse())} {thisDirMethod}");
}
return(Task.CompletedTask);
}
private static void Recurse(TreeNode parentNode, IDirectoryStructure parent, int remainingDepth)
{
if (remainingDepth <= 0)
{
return;
}
foreach (string child in parent.DirectoryNames)
{
IDirectoryStructure dir = parent.GetChildDirectory(child);
string methods = dir.RequestInfo?.GetDirectoryMethodListing();
TreeNode node = parentNode.AddChild(child, methods);
Recurse(node, dir, remainingDepth - 1);
}
}
public static IDirectoryStructure TraverseTo(this IDirectoryStructure structure, IEnumerable <string> pathParts)
{
structure = structure ?? throw new ArgumentNullException(nameof(structure));
IDirectoryStructure s = structure;
if (pathParts is null)
{
return(s);
}
IReadOnlyList <string> parts = pathParts.ToList();
if (parts.Count == 0)
{
return(s);
}
if (parts[0].Length == 0 && parts.Count > 1)
{
while (s.Parent != null)
{
s = s.Parent;
}
}
foreach (string part in parts)
{
if (part == ".")
{
continue;
}
if (part == "..")
{
s = s?.Parent ?? s;
}
else if (!string.IsNullOrEmpty(part) && s is object)
{
s = s.GetChildDirectory(part);
}
}
return(s);
}
public void ReadMetadata_WithNoRequestBody_ReturnsApiDefinition()
{
string json = @"{
""openapi"": ""3.0.0"",
""paths"": {
""/pets"": {
""get"": {
""responses"": {
""200"": {
""description"": ""Success""
}
}
},
""post"": {
""summary"": ""Create a pet"",
""operationId"": ""createPets"",
""responses"": {
""201"": {
""description"": ""Null response""
}
},
""requestBody"": {
""content"": {
}
}
}
}
}
}";
OpenApiDotNetApiDefinitionReader openApiV3ApiDefinitionReader = new OpenApiDotNetApiDefinitionReader();
ApiDefinitionParseResult result = openApiV3ApiDefinitionReader.ReadDefinition(json, null);
Assert.NotNull(result.ApiDefinition?.DirectoryStructure);
Assert.Single(result.ApiDefinition.DirectoryStructure.DirectoryNames);
Assert.Equal("pets", result.ApiDefinition.DirectoryStructure.DirectoryNames.Single());
IDirectoryStructure subDirectory = result.ApiDefinition.DirectoryStructure.TraverseTo("/pets");
Assert.Equal(2, subDirectory.RequestInfo.Methods.Count);
Assert.Contains("Get", subDirectory.RequestInfo.Methods, StringComparer.Ordinal);
Assert.Contains("Post", subDirectory.RequestInfo.Methods, StringComparer.Ordinal);
}
public void ReadMetadata_WithContentAndMultipleContentTypes_ReturnsApiDefinitionWithContentTypes()
{
string json = @"{
""openapi"": ""3.0.0"",
""paths"": {
""/pets"": {
""post"": {
""summary"": ""Create a pet"",
""operationId"": ""createPets"",
""responses"": {
""201"": {
""description"": ""Null response""
}
},
""requestBody"": {
""description"": ""A Request Body"",
""required"": false,
""content"": {
""application/json"": {
},
""text/plain"": {
}
}
}
}
}
}
}";
OpenApiDotNetApiDefinitionReader openApiV3ApiDefinitionReader = new OpenApiDotNetApiDefinitionReader();
ApiDefinition apiDefinition = openApiV3ApiDefinitionReader.ReadDefinition(json, null);
Assert.NotNull(apiDefinition?.DirectoryStructure);
Assert.Single(apiDefinition.DirectoryStructure.DirectoryNames);
Assert.Equal("pets", apiDefinition.DirectoryStructure.DirectoryNames.Single());
IDirectoryStructure subDirectory = apiDefinition.DirectoryStructure.TraverseTo("/pets");
Assert.Single(subDirectory.RequestInfo.Methods);
Assert.Contains("Post", subDirectory.RequestInfo.Methods, StringComparer.Ordinal);
Assert.Equal(2, subDirectory.RequestInfo.ContentTypesByMethod["post"].Count);
Assert.Contains("application/json", subDirectory.RequestInfo.ContentTypesByMethod["post"]);
Assert.Contains("text/plain", subDirectory.RequestInfo.ContentTypesByMethod["post"]);
}
public void ReadMetadata_WithNoResponses_ReturnsApiDefinitionWithNoRequestInfo()
{
string json = @"{
""openapi"": ""3.0.0"",
""paths"": {
""/pets"": {
}
}
}";
OpenApiDotNetApiDefinitionReader openApiV3ApiDefinitionReader = new OpenApiDotNetApiDefinitionReader();
ApiDefinition apiDefinition = openApiV3ApiDefinitionReader.ReadDefinition(json, null);
IDirectoryStructure subDirectory = apiDefinition.DirectoryStructure.TraverseTo("/pets");
Assert.Null(subDirectory.RequestInfo);
}
public void Suggest_WithMoreThanThreeParseResultSectionsAndNoMatchingCompletions_ReturnsNothing()
{
ArrangeInputs(parseResultSections: "set header CONTENT-TYPE z",
out MockedShellState shellState,
out HttpState httpState,
out ICoreParseResult parseResult,
caretPosition: 25);
IDirectoryStructure directoryStructure = GetDirectoryStructure("testMethod", "testContentType", "testBody");
httpState.Structure = directoryStructure;
httpState.BaseAddress = new Uri("http://localhost:5050/");
SetHeaderCommand setHeaderCommand = new SetHeaderCommand();
IEnumerable <string> suggestions = setHeaderCommand.Suggest(shellState, httpState, parseResult);
Assert.Empty(suggestions);
}
private TreeNode GetDirectoryNode(IDirectoryStructure directory)
{
TreeNode directoryNode;
TreeNode subDirectoryNode;
directoryNode = new TreeNode(directory.DirectoryName);
directoryNode.Tag = directory;
directoryNode.ImageKey = "normalFolder";
directoryNode.SelectedImageKey = "openFolder";
foreach (IDirectoryStructure d in directory.SubDirectories)
{
subDirectoryNode = GetDirectoryNode(d);
directoryNode.Nodes.Add(subDirectoryNode);
}
return(directoryNode);
}
private static void Recurse(TreeNode parentNode, IDirectoryStructure parent, int remainingDepth)
{
if (remainingDepth <= 0)
{
return;
}
foreach (string child in parent.DirectoryNames)
{
IDirectoryStructure dir = parent.GetChildDirectory(child);
string methods = dir.RequestInfo != null && dir.RequestInfo.Methods.Count > 0
? "[" + string.Join("|", dir.RequestInfo.Methods) + "]"
: "[]";
TreeNode node = parentNode.AddChild(child, methods);
Recurse(node, dir, remainingDepth - 1);
}
}
public void Suggest_WithMoreThanThreeParseResultSectionsAndSelectedSectionAtThree_ReturnsValueCompletion()
{
ArrangeInputs(parseResultSections: "set header CONTENT-TYPE t",
out MockedShellState shellState,
out HttpState httpState,
out ICoreParseResult parseResult,
caretPosition: 25);
IDirectoryStructure directoryStructure = GetDirectoryStructure("testMethod", "testContentType", "testBody");
httpState.Structure = directoryStructure;
httpState.BaseAddress = new Uri("http://localhost:5050/");
SetHeaderCommand setHeaderCommand = new SetHeaderCommand();
List <string> suggestions = setHeaderCommand.Suggest(shellState, httpState, parseResult).ToList();
Assert.Single(suggestions);
Assert.Equal("testContentType", suggestions.First());
}
public void ReadMetadata_WithNoOperations_ReturnsApiDefinitionWithNullRequestInfo()
{
string json = @"{
""swaggerVersion"": ""1.2"",
""apis"": [
{
""path"": ""/user/logout"",
}
]
}";
JObject jobject = JObject.Parse(json);
SwaggerV1ApiDefinitionReader swaggerV1ApiDefinitionReader = new SwaggerV1ApiDefinitionReader();
ApiDefinition apiDefinition = swaggerV1ApiDefinitionReader.ReadDefinition(jobject, null);
IDirectoryStructure subDirectory = apiDefinition.DirectoryStructure.TraverseTo("/user/logout");
Assert.Null(subDirectory.RequestInfo);
}
private void openSelectedFolder()
{
if (this.fileListView.SelectedItems.Count == 1)
{
if (this.fileListView.SelectedItems[0].Tag is IDirectoryStructure)
{
IDirectoryStructure clickedDirectory = (IDirectoryStructure)this.fileListView.SelectedItems[0].Tag;
// find the item in the tree and select it
foreach (TreeNode t in this.IsoFolderTreeView.SelectedNode.Nodes)
{
if (((IDirectoryStructure)t.Tag).Equals(clickedDirectory))
{
this.IsoFolderTreeView.SelectedNode = t;
t.Expand();
}
}
}
}
}
public void ReadMetadata_WithNoContent_ReturnsApiDefinitionWithRequestMethodButNoContentTypes()
{
string json = @"{
""openapi"": ""3.0.0"",
""info"": {
""title"": ""OpenAPI v3 Spec"",
""version"": ""v1""
},
""paths"": {
""/pets"": {
""post"": {
""summary"": ""Create a pet"",
""operationId"": ""createPets"",
""responses"": {
""201"": {
""description"": ""Null response""
}
},
""requestBody"": {
""description"": ""A Request Body"",
""required"": false
}
}
}
}
}";
OpenApiDotNetApiDefinitionReader openApiV3ApiDefinitionReader = new OpenApiDotNetApiDefinitionReader();
ApiDefinition apiDefinition = openApiV3ApiDefinitionReader.ReadDefinition(json, null);
Assert.NotNull(apiDefinition?.DirectoryStructure);
Assert.Single(apiDefinition.DirectoryStructure.DirectoryNames);
Assert.Equal("pets", apiDefinition.DirectoryStructure.DirectoryNames.Single());
IDirectoryStructure subDirectory = apiDefinition.DirectoryStructure.TraverseTo("/pets");
Assert.Single(subDirectory.RequestInfo.Methods);
Assert.Contains("Post", subDirectory.RequestInfo.Methods, StringComparer.Ordinal);
Assert.DoesNotContain("post", subDirectory.RequestInfo.ContentTypesByMethod.Keys, StringComparer.Ordinal);
}
public async Task ExecuteAsync_WithRelativeUrlAndBaseAddress_SetsApiDefinition()
{
string response = @"{
""swagger"": ""2.0"",
""paths"": {
""/api/Values"": {
""post"": {
}
}
}
}";
string swaggerAddress = "/swagger.json";
string baseAddress = "http://localhost/";
string requestAddress = "http://localhost/swagger.json";
string parseResultSections = "set swagger " + swaggerAddress;
IDirectoryStructure directoryStructure = await GetDirectoryStructure(response, parseResultSections, requestAddress, baseAddress).ConfigureAwait(false);
Assert.NotNull(directoryStructure);
}
