private string SimplifyJson(string responseText)
{
switch (_options.Type)
{
case AvmObjectType.BuildVariables:
case AvmObjectType.VariableGroupVariables:
return(JsonConvert.SerializeObject(JsonConvert.DeserializeObject <dynamic>(responseText).variables));
case AvmObjectType.ReleaseVariables:
var release = JsonConvert.DeserializeObject <dynamic>(responseText);
var output = new ReleaseVariables
{
Variables = JsonConvert.DeserializeObject <Dictionary <string, Variable> >(
JsonConvert.SerializeObject(release.variables)),
Environments =
JsonConvert.DeserializeObject <List <PipelineEnvironment> >(
JsonConvert.SerializeObject(release.environments))
};
return(JsonConvert.SerializeObject(
output
));
}
return(responseText);
}
public void UpdateRelease_SetsVariableValue()
{
// Arrange
string variableName = "variable1";
var existing = CreatePartiallyValidRelease();
existing["variables"][variableName] = new JObject();
var newRelease = new ReleaseVariables
{
Variables = new Dictionary <string, Variable>
{
{ variableName, new Variable
{
Value = "New value"
} }
}
};
// Act
var output = JsonConvert.DeserializeObject <JObject>(new ReleaseTransformer().UpdateRelease(JsonConvert.SerializeObject(existing),
JsonConvert.SerializeObject(newRelease)));
// Assert
Assert.Equal("New value", output["variables"][variableName]["value"]);
}
private static void SetReleaseEnvironmentSpecificVariables(ReleaseVariables newReleaseVariables,
JToken existingRelease)
{
foreach (var env in newReleaseVariables.Environments)
{
GetEnvironment(existingRelease, env).SetVariables(env.Variables);
}
}
public async Task ExecuteAsync_UploadsCorrectlyModifiedRelease()
{
// Arrange
var release = TestUtilities.CreateValidRelease();
var env = TestUtilities.CreateValidReleaseEnvironment();
((JArray)release["environments"]).Add(env);
var expectedRelease = TestUtilities.CreateValidRelease();
expectedRelease["variables"]["Variable"] = TestUtilities.CreateValidVariableJObject();
env = TestUtilities.CreateValidReleaseEnvironment();
((JArray)expectedRelease["environments"]).Add(env);
env["variables"]["Variable"] = TestUtilities.CreateValidVariableJObject();
var variablesFileContent = new ReleaseVariables
{
Environments = new List <PipelineEnvironment>
{
new PipelineEnvironment
{
Id = 1,
Name = "Release 1",
Variables = new Dictionary <string, Variable>
{
{ "Variable", TestUtilities.CreateValidVariable() }
}
}
},
Variables = new Dictionary <string, Variable>
{
{ "Variable", TestUtilities.CreateValidVariable() }
}
};
var options = CreateValidSetOptions(AvmObjectType.ReleaseVariables);
File.WriteAllText(options.SourceFilePath, JsonConvert.SerializeObject(variablesFileContent));
var azureClient = CreateValidAzureClient();
azureClient.GetAsync(Arg.Any <string>()).Returns(JsonConvert.SerializeObject(release));
var output = CreateValidOutput();
var urlStore = CreateValidUrlStore();
var setCommand = new SetCommand(options, new ReleaseTransformer(), new VariableContainerTransformer(), urlStore, azureClient, output);
// Act
await setCommand.ExecuteAsync();
File.Delete(options.SourceFilePath);
// Assert
await azureClient.Received().PutAsync(Arg.Any <string>(),
Arg.Is <string>(res => JToken.DeepEquals(JsonConvert.DeserializeObject <JToken>(res), expectedRelease)));
}
public void UpdateRelease_UpdatesCorrectEnvironment()
{
// Arrange
var release = CreatePartiallyValidRelease();
var envArray = new JArray();
var env1 = new JObject();
env1["id"] = 1;
env1["variables"] = new JObject();
var env2 = new JObject();
env2["id"] = 2;
env2["variables"] = new JObject();
envArray.Add(env1);
envArray.Add(env2);
release["environments"] = envArray;
var releaseVariables = new ReleaseVariables
{
Variables = new Dictionary <string, Variable>(),
Environments = new List <PipelineEnvironment>
{
new PipelineEnvironment
{
Id = 2,
Variables = new Dictionary <string, Variable>
{
{ "Variable1", new Variable
{
Value = "Value"
} }
}
}
}
};
var releaseTransformer = new ReleaseTransformer();
// Act
var output = releaseTransformer.UpdateRelease(JsonConvert.SerializeObject(release),
JsonConvert.SerializeObject(releaseVariables));
// Assert
Assert.Equal("Value", JsonConvert.DeserializeObject <JObject>(output)
.SelectToken($"$.environments[?(@.id == 2)].variables")["Variable1"]
.ToObject <Variable>()
.Value);
}
public void UpdateRelease_SetsVariableValueToNull_IfNewValueIsNull()
{
// Arrange
string variableName = "variable1";
var existing = CreatePartiallyValidRelease();
existing["variables"][variableName] = new JObject();
existing["variables"][variableName]["value"] = "value";
var newRelease = new ReleaseVariables
{
Variables = new Dictionary <string, Variable>
{
{ variableName, null }
}
};
// Act
var output = JsonConvert.DeserializeObject <JObject>(new ReleaseTransformer().UpdateRelease(JsonConvert.SerializeObject(existing),
JsonConvert.SerializeObject(newRelease)));
// Assert
Assert.Null(output["variables"][variableName].ToObject(typeof(object)));
}
public void UpdateRelease_ThrowsArgumentException_WhenEnvironmentDoesntExist()
{
// Arrange
var release = CreatePartiallyValidRelease();
var releaseVariables = new ReleaseVariables
{
Variables = new Dictionary <string, Variable>(),
Environments = new List <PipelineEnvironment>
{
new PipelineEnvironment
{
Id = 1
}
}
};
var releaseTransformer = new ReleaseTransformer();
// Act
Assert.Throws <ArgumentException>(() => releaseTransformer.UpdateRelease(JsonConvert.SerializeObject(release),
JsonConvert.SerializeObject(releaseVariables)));
// Assert
}
private static void SetReleaseGlobalVariables(JToken existingRelease, ReleaseVariables newReleaseVariables)
{
existingRelease.SetVariables(newReleaseVariables.Variables);
}
