protected override void ProcessRecord()
{
using (var clientContext = CreateClientContext())
{
var context = new HarshProvisionerContext(clientContext);
try
{
var provisioner = new HarshProvisioner();
AddChildren(provisioner, Children);
provisioner.ProvisionAsync(context).Wait();
}
catch (AggregateException ex)
{
foreach (var iex in ex.InnerExceptions)
{
WriteError(new ErrorRecord(iex, null, ErrorCategory.OperationStopped, null));
}
}
catch (Exception ex)
{
WriteError(new ErrorRecord(ex, null, ErrorCategory.OperationStopped, null));
}
}
}
public async Task Calls_children_unprovision_in_correct_order()
{
var seq = String.Empty;
var p1 = new Mock<HarshProvisioner>();
var p2 = new Mock<HarshProvisioner>();
p1.Protected()
.Setup<Task>("OnUnprovisioningAsync")
.Returns(HarshTask.Completed)
.Callback(() => seq += "1");
p2.Protected()
.Setup<Task>("OnUnprovisioningAsync")
.Returns(HarshTask.Completed)
.Callback(() => seq += "2");
var ctx = Context.AllowDeleteUserData();
var composite = new HarshProvisioner()
{
Children = { p1.Object, p2.Object }
};
await composite.UnprovisionAsync(ctx);
Assert.Equal("21", seq);
}
public async Task Calls_children_unprovision_in_correct_order()
{
var seq = String.Empty;
var p1 = new Mock <HarshProvisioner>();
var p2 = new Mock <HarshProvisioner>();
p1.Protected()
.Setup <Task>("OnUnprovisioningAsync")
.Returns(HarshTask.Completed)
.Callback(() => seq += "1");
p2.Protected()
.Setup <Task>("OnUnprovisioningAsync")
.Returns(HarshTask.Completed)
.Callback(() => seq += "2");
var ctx = Context.AllowDeleteUserData();
var composite = new HarshProvisioner()
{
Children = { p1.Object, p2.Object }
};
await composite.UnprovisionAsync(ctx);
Assert.Equal("21", seq);
}
protected override void ProcessRecord()
{
using (var clientContext = CreateClientContext())
{
var context = new HarshProvisionerContext(clientContext);
try
{
var provisioner = new HarshProvisioner();
AddChildren(provisioner, Children);
provisioner.ProvisionAsync(context).Wait();
}
catch (AggregateException ex)
{
foreach (var iex in ex.InnerExceptions)
{
WriteError(new ErrorRecord(iex, null, ErrorCategory.OperationStopped, null));
}
}
catch (Exception ex)
{
WriteError(new ErrorRecord(ex, null, ErrorCategory.OperationStopped, null));
}
}
}
public void Adds_sub_provisioner()
{
var parent = new HarshProvisioner();
var child = new HarshProvisioner();
HarshProvisionerCmdlet.AddChild(parent, child);
Assert.Contains(child, parent.Children);
}
public void ToServerProvisioner_cannot_have_children()
{
var clientProv = new HarshProvisioner();
var serverProv = clientProv.ToServerProvisioner();
Assert.Throws <NotSupportedException>(() =>
serverProv.Children.Add(new HarshServerProvisioner())
);
}
private static Boolean HasDefaultValue(
Parameter parameter, HarshProvisioner provisioner
)
{
if (parameter.HasDefaultValue(provisioner))
{
Logger.Information(
"Parameter {Parameter} has default value, skipping."
);
return(true);
}
return(false);
}
public async Task Adds_default_context_tag()
{
var parent = new HarshProvisioner()
{
Children = { new ExpectsTag() }
};
var tag = new Tag()
{
Value = 42
};
HarshProvisionerCmdlet.AddChild(parent, tag);
await parent.ProvisionAsync(Context);
}
public async Task Assigns_context_to_children()
{
var p = new Mock <HarshProvisioner>();
p.Protected()
.Setup <Task>("OnProvisioningAsync")
.Returns(HarshTask.Completed)
.Callback(() =>
{
Assert.Equal(Web, p.Object.Web);
});
var composite = new HarshProvisioner()
{
Children = { p.Object }
};
await composite.ProvisionAsync(Context);
}
public Boolean Update(
ClientObject clientObject,
HarshProvisioner provisioner
)
{
if (provisioner == null)
{
throw Logger.Fatal.ArgumentNull(nameof(provisioner));
}
if (provisioner.ParameterSet == null)
{
throw Logger.Fatal.Argument(
nameof(provisioner),
SR.ClientObjectUpdater_NoParameterSet
);
}
return(Update(
clientObject,
provisioner,
provisioner.ParameterSet.Parameters
));
}
public ClientProvisionerWrapper(HarshProvisioner provisioner)
{
Provisioner = provisioner;
}
public ClientProvisionerWrapper(HarshProvisioner provisioner)
{
Provisioner = provisioner;
}
public async Task Assigns_context_to_children()
{
var p = new Mock<HarshProvisioner>();
p.Protected()
.Setup<Task>("OnProvisioningAsync")
.Returns(HarshTask.Completed)
.Callback(() =>
{
Assert.Equal(Web, p.Object.Web);
});
var composite = new HarshProvisioner()
{
Children = { p.Object }
};
await composite.ProvisionAsync(Context);
}
public Boolean Update(
ClientObject clientObject,
HarshProvisioner provisioner,
IEnumerable <Parameter> parameters
)
{
if (clientObject == null)
{
throw Logger.Fatal.ArgumentNull(nameof(clientObject));
}
if (provisioner == null)
{
throw Logger.Fatal.ArgumentNull(nameof(provisioner));
}
if (parameters == null)
{
throw Logger.Fatal.ArgumentNull(nameof(parameters));
}
var maps = from p in parameters
where !HasDefaultValue(p, provisioner)
let clientObjectAccessor = TryGetClientObjectAccessor(p)
where clientObjectAccessor != null
let existingValue = clientObjectAccessor.GetValue(clientObject)
select new
{
Parameter = p,
ParameterValue = p.GetValue(provisioner),
ClientObjectAccessor = clientObjectAccessor,
ClientObjectValue = existingValue
};
var changed = false;
foreach (var m in maps)
{
if (Equals(m.ParameterValue, m.ClientObjectValue))
{
Logger.Information(
"Parameter {Parameter} value {$ParameterValue} " +
"equals to client object {ClientObjectProperty} " +
"value {$ClientObjectValue}.",
m.Parameter,
m.ParameterValue,
m.ClientObjectAccessor,
m.ClientObjectValue
);
}
else
{
changed = true;
Logger.Information(
"Updating client object {ClientObjectProperty}, " +
"current value {$ClientObjectValue} does not equal " +
"{Parameter} value {$ParameterValue}.",
m.ClientObjectAccessor,
m.ClientObjectValue,
m.Parameter,
m.ParameterValue
);
m.ClientObjectAccessor.SetValue(
clientObject,
m.ParameterValue
);
}
}
return(changed);
}
