public static void TestListInstalledPackages(
IntegrationTester.TestCase testCase,
Action <IntegrationTester.TestCaseResult> testCaseComplete)
{
var testCaseResult = new IntegrationTester.TestCaseResult(testCase);
PackageManagerClient.ListInstalledPackages((result) => {
// Unity 2017.x doesn't install any default packages.
if (ExecutionEnvironment.VersionMajorMinor >= 2018.0)
{
// Make sure a subset of the default packages installed in all a newly created
// Unity project are present in the returned list.
CheckPackageNamesInPackageInfos(
new List <string>()
{
"com.unity.modules.audio",
"com.unity.modules.physics"
},
result.Packages, testCaseResult, "Found an unexpected set of packages");
}
var message = String.Format(
"Error: '{0}', PackageInfos:\n{1}\n",
result.Error,
String.Join("\n", PackageInfoListToStringList(result.Packages).ToArray()));
if (!String.IsNullOrEmpty(result.Error.ToString()))
{
testCaseResult.ErrorMessages.Add(message);
}
else
{
UnityEngine.Debug.Log(message);
}
testCaseComplete(testCaseResult);
});
}
public static void TestAddAndRemovePackage(
IntegrationTester.TestCase testCase,
Action <IntegrationTester.TestCaseResult> testCaseComplete)
{
var testCaseResult = new IntegrationTester.TestCaseResult(testCase);
const string packageToModify = "com.unity.ads";
PackageManagerClient.AddPackage(
packageToModify,
(result) => {
if (UpmAvailable)
{
CheckChangeResult(result.Error,
result.Package != null ? result.Package.Name : null,
packageToModify, testCaseResult);
}
});
PackageManagerClient.RemovePackage(
packageToModify,
(result) => {
var message = UpmAvailable ?
CheckChangeResult(result.Error, result.PackageId, packageToModify,
testCaseResult) : "";
if (testCaseResult.ErrorMessages.Count == 0)
{
UnityEngine.Debug.Log(message);
}
testCaseComplete(testCaseResult);
});
}
public static void TestSearchAvailablePackagesAll(
IntegrationTester.TestCase testCase,
Action <IntegrationTester.TestCaseResult> testCaseComplete)
{
var testCaseResult = new IntegrationTester.TestCaseResult(testCase);
PackageManagerClient.SearchAvailablePackages(
(result) => {
// Make sure common optional Unity packages are returned in the search result.
if (UpmSearchAllAvailable)
{
CheckPackageNamesInPackageInfos(
new List <string>()
{
"com.unity.2d.animation",
"com.unity.entities"
},
result.Packages, testCaseResult,
"SearchAvailablePackages returned an unexpected set of packages");
}
var message = String.Format(
"Error: '{0}', PackageInfos:\n{1}\n", result.Error,
String.Join("\n", PackageInfoListToStringList(result.Packages).ToArray()));
if (!String.IsNullOrEmpty(result.Error.ToString()))
{
testCaseResult.ErrorMessages.Add(message);
}
else
{
UnityEngine.Debug.Log(message);
}
testCaseComplete(testCaseResult);
});
}
public PackageViewModel(DynamoViewModel dynamoViewModel, Package model)
{
this.dynamoViewModel = dynamoViewModel;
this.dynamoModel = dynamoViewModel.Model;
var pmExtension = dynamoModel.GetPackageManagerExtension();
this.packageManagerClient = pmExtension.PackageManagerClient;
Model = model;
ToggleTypesVisibleInManagerCommand = new DelegateCommand(() => { }, () => true);
GetLatestVersionCommand = new DelegateCommand(() => { }, () => false);
PublishNewPackageVersionCommand = new DelegateCommand(() => ExecuteWithTou(PublishNewPackageVersion), () => CanPublish);
PublishNewPackageCommand = new DelegateCommand(() => ExecuteWithTou(PublishNewPackage), () => CanPublish);
UninstallCommand = new DelegateCommand(Uninstall, CanUninstall);
UnmarkForUninstallationCommand = new DelegateCommand(UnmarkForUninstallation, CanUnmarkForUninstallation);
LoadCommand = new DelegateCommand(Load, CanLoad);
DeprecateCommand = new DelegateCommand(Deprecate, CanDeprecate);
UndeprecateCommand = new DelegateCommand(Undeprecate, CanUndeprecate);
GoToRootDirectoryCommand = new DelegateCommand(GoToRootDirectory, () => true);
Model.LoadedAssemblies.CollectionChanged += LoadedAssembliesOnCollectionChanged;
Model.PropertyChanged += ModelOnPropertyChanged;
this.dynamoModel.WorkspaceAdded += WorkspaceAdded;
this.dynamoModel.WorkspaceRemoved += WorkspaceRemoved;
}
public void Execute(object parameters)
{
this._client = dynSettings.Controller.PackageManagerClient;
var nodeList = DynamoSelection.Instance.Selection
.Where(x => x is dynFunction)
.Cast <dynFunction>()
.Select(x => x.Definition.FunctionId)
.ToList();
if (!nodeList.Any())
{
MessageBox.Show("You must select at least one custom node.", "Selection Error", MessageBoxButton.OK, MessageBoxImage.Question);
return;
}
var defs = nodeList.Select(dynSettings.CustomNodeManager.GetFunctionDefinition).ToList();
if (defs.Any(x => x == null))
{
MessageBox.Show("There was a problem getting the node from the workspace.", "Selection Error", MessageBoxButton.OK, MessageBoxImage.Question);
}
DynamoCommands.ShowNodeNodePublishInfoCmd.Execute(defs);
}
public void DoesCurrentUserOwnPackage_ReturnsTrueWhenCurrentUserIsTheOwner()
{
var id = "1";
var usrname = "abcd";
User usr = new User {
_id = id,
username = usrname
};
var mp = new ResponseWithContentBody <PackageHeader>
{
content = new PackageHeader()
{
_id = id,
maintainers = new List <User> {
usr
}
},
success = true
};
var c = new Mock <IGregClient>();
c.Setup(x =>
x.ExecuteAndDeserializeWithContent <PackageHeader>(It.IsAny <HeaderDownload>()))
.Returns(mp);
var pc = new PackageManagerClient(c.Object, MockMaker.Empty <IPackageUploadBuilder>(), "");
var res = pc.DoesCurrentUserOwnPackage(new Package("1", "1", "2.0.4", "1"), usrname);
Assert.IsTrue(res);
}
public void ListAll_ReturnsNonEmptyListWhenPackagesAreAvailable()
{
// Returned content
var mpl = new ResponseWithContentBody <List <PackageHeader> >
{
content = new List <PackageHeader>()
{
new PackageHeader()
},
success = true
};
// Returns mpl for any arguments
var c = new Mock <IGregClient>();
c.Setup(x =>
x.ExecuteAndDeserializeWithContent <List <PackageHeader> >(It.IsAny <HeaderCollectionDownload>()))
.Returns(mpl);
var m = new PackageManagerClient(c.Object, MockMaker.Empty <IPackageUploadBuilder>());
var pl = m.ListAll();
Assert.AreNotEqual(0, pl.Count());
}
public void DownloadPackageHeader_SucceedsForValidPackage()
{
var id = "1";
// Returned content
var mp = new ResponseWithContentBody <PackageHeader>
{
content = new PackageHeader()
{
_id = id
},
success = true
};
// Returns mock for any arguments
var c = new Mock <IGregClient>();
c.Setup(x =>
x.ExecuteAndDeserializeWithContent <PackageHeader>(It.IsAny <HeaderDownload>()))
.Returns(mp);
var pc = new PackageManagerClient(c.Object, MockMaker.Empty <IPackageUploadBuilder>());
PackageHeader header;
var res = pc.DownloadPackageHeader(id, out header);
Assert.AreEqual(id, header._id);
Assert.IsTrue(res.Success);
}
public void DownloadPackageHeader_SucceedsForValidPackage()
{
var id = "1";
// Returned content
var mp = new ResponseWithContentBody<PackageHeader>
{
content = new PackageHeader()
{
_id = id
},
success = true
};
// Returns mock for any arguments
var c = new Mock<IGregClient>();
c.Setup(x =>
x.ExecuteAndDeserializeWithContent<PackageHeader>(It.IsAny<HeaderDownload>()))
.Returns(mp);
var pc = new PackageManagerClient(c.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
PackageHeader header;
var res = pc.DownloadPackageHeader(id, out header);
Assert.AreEqual(id, header._id);
Assert.IsTrue(res.Success);
}
public TermsOfUseHelper(TermsOfUseHelperParams touParams)
{
if (touParams == null)
{
throw new ArgumentNullException("touParams");
}
if (touParams.PackageManagerClient == null)
{
throw new ArgumentNullException("PackageManagerClient");
}
if (touParams.AuthenticationManager == null)
{
throw new ArgumentNullException("AuthenticationManager");
}
if (touParams.AcceptanceCallback == null)
{
throw new ArgumentNullException("AcceptanceCallback");
}
if (touParams.ResourceProvider == null)
{
throw new ArgumentNullException("ResourceProvider");
}
resourceProvider = touParams.ResourceProvider;
packageManagerClient = touParams.PackageManagerClient;
callbackAction = touParams.AcceptanceCallback;
authenticationManager = touParams.AuthenticationManager;
}
public PackageManagerClientViewModel(DynamoViewModel dynamoViewModel, PackageManagerClient packageManagerClient)
{
this.dynamoViewModel = dynamoViewModel;
this.packageManagerClient = packageManagerClient;
this.CachedPackageList = new List <PackageManagerSearchElement>();
this.packageManagerClient.RequestAuthentication +=
dynamoViewModel.OnRequestAuthentication;
}
/// <summary>
/// Callback for registering an authentication provider with the package manager
/// </summary>
/// <param name="client">The client, to which the provider will be attached</param>
void RegisterSingleSignOn(PackageManagerClient client)
{
if (_singleSignOnAssembly == null)
{
_singleSignOnAssembly = LoadSSONet();
}
client.Client.Provider = new RevitOxygenProvider();
}
public PackageManagerClientViewModel(DynamoViewModel dynamoViewModel, PackageManagerClient model)
{
this.DynamoViewModel = dynamoViewModel;
Model = model;
CachedPackageList = new List <PackageManagerSearchElement>();
this.ToggleLoginStateCommand = new DelegateCommand(ToggleLoginState, CanToggleLoginState);
model.LoginStateChanged += b => RaisePropertyChanged("LoginState");
}
public void SetTermsOfUseAcceptanceStatus_ReturnsTrueWhenRequestThrowsAnException()
{
var gc = new Mock <IGregClient>();
gc.Setup(x => x.ExecuteAndDeserializeWithContent <TermsOfUseStatus>(It.IsAny <TermsOfUse>())).Throws <Exception>();
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>());
var res = pc.SetTermsOfUseAcceptanceStatus();
Assert.IsFalse(res);
}
public void Downvote_ReturnsFalseWhenRequestThrowsException()
{
var gc = new Mock <IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny <Downvote>())).Throws <Exception>();
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>());
var res = pc.Downvote("id");
Assert.IsFalse(res);
}
public void Undeprecate_ReturnsFailureObjectWhenRequestThrowsException()
{
var gc = new Mock <IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny <Undeprecate>())).Throws(new Exception());
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>());
var res = pc.Undeprecate("id");
Assert.IsFalse(res.Success);
}
public void ListAll_ReturnsEmptyListWhenQueryThrowsException()
{
// Returns mpl for any arguments
var c = new Mock<IGregClient>();
c.Setup(x =>
x.ExecuteAndDeserializeWithContent<List<PackageHeader>>(It.IsAny<HeaderCollectionDownload>()))
.Throws(new Exception("Fail!"));
var m = new PackageManagerClient(c.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var pl = m.ListAll();
Assert.AreEqual(0, pl.Count());
}
/// <summary>
/// Class constructor
/// </summary>
public DynamoController(ExecutionEnvironment env, Type viewModelType, string context)
{
dynSettings.Controller = this;
this.Context = context;
//Start heartbeat reporting
Services.InstrumentationLogger.Start();
//create the view model to which the main window will bind
//the DynamoModel is created therein
this.DynamoViewModel = (DynamoViewModel)Activator.CreateInstance(viewModelType, new object[] { this });
// custom node loader
string directory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string pluginsPath = Path.Combine(directory, "definitions");
CustomNodeManager = new CustomNodeManager(pluginsPath);
SearchViewModel = new SearchViewModel();
PackageManagerClient = new PackageManagerClient();
dynSettings.PackageManagerClient = PackageManagerClient;
PublishPackageViewModel = new PublishPackageViewModel(PackageManagerClient);
dynSettings.PackageLoader = new PackageLoader();
dynSettings.PackageLoader.DoCachedPackageUninstalls();
dynSettings.PackageLoader.LoadPackages();
FSchemeEnvironment = env;
DynamoViewModel.Model.CurrentSpace.X = DynamoView.CANVAS_OFFSET_X;
DynamoViewModel.Model.CurrentSpace.Y = DynamoView.CANVAS_OFFSET_Y;
dynSettings.Controller.DynamoViewModel.Log(String.Format(
"Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
DynamoLoader.ClearCachedAssemblies();
DynamoLoader.LoadBuiltinTypes();
//run tests
if (FScheme.RunTests(dynSettings.Controller.DynamoViewModel.Log))
{
dynSettings.Controller.DynamoViewModel.Log("All Tests Passed. Core library loaded OK.");
}
NodeSubmittedForRendering += new EventHandler(Controller_NodeSubmittedForRendering);
NodeRemovedFromRendering += new EventHandler(Controller_NodeRemovedFromRendering);
}
public void DownloadPackage_ReturnsFailureObjectWhenDownloadThrowsAnException()
{
var gc = new Mock <IGregClient>();
gc.Setup(x => x.Execute(It.IsAny <PackageDownload>())).Throws(new Exception("Failed to get your package!"));
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>());
string downloadPath;
var res = pc.DownloadPackage("1", "0.1", out downloadPath);
Assert.IsNull(downloadPath);
Assert.IsFalse(res.Success);
}
public void FailureOnGetPackageVersionHeaderByPackageName()
{
var mockGreg = new Mock <IGregClient>();
mockGreg.Setup(m => m.ExecuteAndDeserializeWithContent <PackageVersion>(It.IsAny <Request>()))
.Returns(new ResponseWithContentBody <PackageVersion>()
{
message = "The package does not exist",
success = false
});
var client = new PackageManagerClient(mockGreg.Object, MockMaker.Empty <IPackageUploadBuilder>(), string.Empty);
client.GetPackageVersionHeader(string.Empty, string.Empty);
}
public void Deprecate_ReturnsSuccessObjectWhenRequestSucceeds()
{
var gc = new Mock <IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny <Deprecate>())).Returns(new ResponseBody()
{
success = true
});
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>());
var res = pc.Deprecate("id");
Assert.IsTrue(res.Success);
}
public void ListAll_ReturnsEmptyListWhenQueryThrowsException()
{
// Returns mpl for any arguments
var c = new Mock <IGregClient>();
c.Setup(x =>
x.ExecuteAndDeserializeWithContent <List <PackageHeader> >(It.IsAny <HeaderCollectionDownload>()))
.Throws(new Exception("Fail!"));
var m = new PackageManagerClient(c.Object, MockMaker.Empty <IPackageUploadBuilder>());
var pl = m.ListAll();
Assert.AreEqual(0, pl.Count());
}
public void Undeprecate_ReturnsFailureObjectWhenRequestFails()
{
var gc = new Mock <IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny <Undeprecate>())).Returns(new ResponseBody()
{
success = false // set to false
});
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>());
var res = pc.Undeprecate("id");
Assert.IsFalse(res.Success);
}
internal PackageManagerClientViewModel(DynamoViewModel dynamoViewModel, PackageManagerClient model)
{
this.DynamoViewModel = dynamoViewModel;
this.AuthenticationManager = dynamoViewModel.Model.AuthenticationManager;
Model = model;
CachedPackageList = new List <PackageManagerSearchElement>();
this.ToggleLoginStateCommand = new DelegateCommand(ToggleLoginState, CanToggleLoginState);
AuthenticationManager.LoginStateChanged += (loginState) =>
{
RaisePropertyChanged("LoginState");
RaisePropertyChanged("Username");
};
}
public void DownloadPackageHeader_ReturnsFailureObjectWhenDownloadThrowsAnException()
{
// Returns mock for any arguments
var c = new Mock <IGregClient>();
c.Setup(x =>
x.ExecuteAndDeserializeWithContent <PackageHeader>(It.IsAny <HeaderDownload>()))
.Throws <Exception>();
var pc = new PackageManagerClient(c.Object, MockMaker.Empty <IPackageUploadBuilder>());
PackageHeader header;
var res = pc.DownloadPackageHeader("1", out header);
Assert.IsFalse(res.Success);
}
public void Publish_SetsErrorStatusWhenRequestThrowsAnException()
{
var gc = new Mock <IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny <PackageUpload>())).Throws <Exception>();
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>());
var pkg = new Package("", "Package", "0.1.0", "MIT");
var handle = new PackageUploadHandle(PackageUploadBuilder.NewRequestBody(pkg));
pc.Publish(pkg, Enumerable.Empty <string>(), false, handle);
Assert.AreEqual(PackageUploadHandle.State.Error, handle.UploadState);
}
public void Login_CausesLoginMethodToBeInvokedOnAuthProvider()
{
var called = false;
var ap = new Mock <IAuthProvider>();
ap.Setup(x => x.Login()).Callback(() => called = true);
var gc = new Mock <IGregClient>();
gc.Setup(x => x.AuthProvider).Returns(ap.Object);
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>());
pc.Login();
Assert.IsTrue(called);
}
public void Publish_SetsErrorStatusWhenResponseIsNull()
{
var gc = new Mock <IGregClient>();
var rb = new ResponseBody();
rb.success = false;
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny <PackageUpload>())).Returns(rb);
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>(), "");
var pkg = new Package("", "Package", "0.1.0", "MIT");
var handle = new PackageUploadHandle(PackageUploadBuilder.NewRequestBody(pkg));
pc.Publish(pkg, Enumerable.Empty <string>(), true, handle);
Assert.AreEqual(PackageUploadHandle.State.Error, handle.UploadState);
}
public void SetTermsOfUseAcceptanceStatus_ReturnsTrueWhenRequestSucceeds()
{
var resp = new ResponseWithContentBody <TermsOfUseStatus>()
{
content = new TermsOfUseStatus()
{
accepted = true
}
};
var gc = new Mock <IGregClient>();
gc.Setup(x => x.ExecuteAndDeserializeWithContent <TermsOfUseStatus>(It.IsAny <TermsOfUse>())).Returns(resp);
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>());
var res = pc.SetTermsOfUseAcceptanceStatus();
Assert.IsTrue(res);
}
public static void TestAddPackage(
IntegrationTester.TestCase testCase,
Action <IntegrationTester.TestCaseResult> testCaseComplete)
{
var testCaseResult = new IntegrationTester.TestCaseResult(testCase);
const string installPackage = "com.unity.analytics";
PackageManagerClient.AddPackage(
installPackage,
(result) => {
var message = UpmAvailable ? CheckChangeResult(
result.Error, result.Package != null ? result.Package.Name : null,
installPackage, testCaseResult) : "";
if (testCaseResult.ErrorMessages.Count == 0)
{
UnityEngine.Debug.Log(message);
}
testCaseComplete(testCaseResult);
});
}
public void SuccessfullyGetPackageVersionHeaderByPackageName()
{
var version = "1.0.0";
var mockGreg = new Mock <IGregClient>();
mockGreg.Setup(m => m.ExecuteAndDeserializeWithContent <PackageVersion>(It.IsAny <Request>()))
.Returns(new ResponseWithContentBody <PackageVersion>()
{
content = new PackageVersion()
{
version = version
},
success = true
});
var client = new PackageManagerClient(mockGreg.Object, MockMaker.Empty <IPackageUploadBuilder>(), string.Empty);
var result = client.GetPackageVersionHeader(string.Empty, version);
Assert.AreEqual(result.version, version);
}
public void Publish_SetsHandleToDoneWhenNewPackageVersionPublishSucceeds()
{
var gc = new Mock <IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny <PackageVersionUpload>()))
.Returns(new ResponseBody()
{
success = true
});
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty <IPackageUploadBuilder>());
var pkg = new Package("", "Package", "0.1.0", "MIT");
var handle = new PackageUploadHandle(PackageUploadBuilder.NewRequestBody(pkg));
pc.Publish(pkg, Enumerable.Empty <string>(), false, handle);
Assert.AreEqual(PackageUploadHandle.State.Uploaded, handle.UploadState);
}
public void ListAll_ReturnsNonEmptyListWhenPackagesAreAvailable()
{
// Returned content
var mpl = new ResponseWithContentBody<List<PackageHeader>>
{
content = new List<PackageHeader>()
{
new PackageHeader()
},
success = true
};
// Returns mpl for any arguments
var c = new Mock<IGregClient>();
c.Setup(x =>
x.ExecuteAndDeserializeWithContent<List<PackageHeader>>(It.IsAny<HeaderCollectionDownload>()))
.Returns(mpl);
var m = new PackageManagerClient(c.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var pl = m.ListAll();
Assert.AreNotEqual(0, pl.Count());
}
public void Publish_SetsErrorStatusWhenRequestThrowsAnException()
{
var gc = new Mock<IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny<PackageUpload>())).Throws<Exception>();
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var pkg = new Package("", "Package", "0.1.0", "MIT");
var handle = new PackageUploadHandle(PackageUploadBuilder.NewRequestBody(pkg));
pc.Publish(pkg, Enumerable.Empty<string>(), false, handle);
Assert.AreEqual(PackageUploadHandle.State.Error, handle.UploadState);
}
public void Publish_SetsErrorStatusWhenResponseIsNull()
{
var gc = new Mock<IGregClient>();
var rb = new ResponseBody();
rb.success = false;
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny<PackageUpload>())).Returns(rb);
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var pkg = new Package("", "Package", "0.1.0", "MIT");
var handle = new PackageUploadHandle(PackageUploadBuilder.NewRequestBody(pkg));
pc.Publish(pkg, Enumerable.Empty<string>(), true, handle);
Assert.AreEqual(PackageUploadHandle.State.Error, handle.UploadState);
}
public void Deprecate_ReturnsSuccessObjectWhenRequestSucceeds()
{
var gc = new Mock<IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny<Deprecate>())).Returns(new ResponseBody()
{
success = true
});
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var res = pc.Deprecate("id");
Assert.IsTrue(res.Success);
}
public void Undeprecate_ReturnsFailureObjectWhenRequestFails()
{
var gc = new Mock<IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny<Undeprecate>())).Returns(new ResponseBody()
{
success = false // set to false
});
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var res = pc.Undeprecate("id");
Assert.IsFalse(res.Success);
}
public void Undeprecate_ReturnsFailureObjectWhenRequestThrowsException()
{
var gc = new Mock<IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny<Undeprecate>())).Throws(new Exception());
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var res = pc.Undeprecate("id");
Assert.IsFalse(res.Success);
}
public void SetTermsOfUseAcceptanceStatus_ReturnsTrueWhenRequestSucceeds()
{
var resp = new ResponseWithContentBody<TermsOfUseStatus>()
{
content = new TermsOfUseStatus()
{
accepted = true
}
};
var gc = new Mock<IGregClient>();
gc.Setup(x => x.ExecuteAndDeserializeWithContent<TermsOfUseStatus>(It.IsAny<TermsOfUse>())).Returns(resp);
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var res = pc.SetTermsOfUseAcceptanceStatus();
Assert.IsTrue(res);
}
public DynamoPackagesUIClient()
{
restClient = new PackageManagerClient(null, ACG_API_URL, ACG_STORAGE_URL);
}
public void Publish_SetsHandleToDoneWhenNewPackageVersionPublishSucceeds()
{
var gc = new Mock<IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny<PackageVersionUpload>()))
.Returns(new ResponseBody()
{
success = true
});
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var pkg = new Package("", "Package", "0.1.0", "MIT");
var handle = new PackageUploadHandle(PackageUploadBuilder.NewRequestBody(pkg));
pc.Publish(pkg, Enumerable.Empty<string>(), false, handle);
Assert.AreEqual(PackageUploadHandle.State.Uploaded, handle.UploadState);
}
public void DownloadPackage_ReturnsFailureObjectWhenDownloadThrowsAnException()
{
var gc = new Mock<IGregClient>();
gc.Setup(x => x.Execute(It.IsAny<PackageDownload>())).Throws(new Exception("Failed to get your package!"));
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
string downloadPath;
var res = pc.DownloadPackage("1", "0.1", out downloadPath);
Assert.IsNull(downloadPath);
Assert.IsFalse(res.Success);
}
public void Downvote_ReturnsFalseWhenRequestThrowsException()
{
var gc = new Mock<IGregClient>();
gc.Setup(x => x.ExecuteAndDeserialize(It.IsAny<Downvote>())).Throws<Exception>();
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var res = pc.Downvote("id");
Assert.IsFalse(res);
}
public void DownloadPackageHeader_ReturnsFailureObjectWhenDownloadThrowsAnException()
{
// Returns mock for any arguments
var c = new Mock<IGregClient>();
c.Setup(x =>
x.ExecuteAndDeserializeWithContent<PackageHeader>(It.IsAny<HeaderDownload>()))
.Throws<Exception>();
var pc = new PackageManagerClient(c.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
PackageHeader header;
var res = pc.DownloadPackageHeader("1", out header);
Assert.IsFalse(res.Success);
}
public void SetTermsOfUseAcceptanceStatus_ReturnsTrueWhenRequestThrowsAnException()
{
var gc = new Mock<IGregClient>();
gc.Setup(x => x.ExecuteAndDeserializeWithContent<TermsOfUseStatus>(It.IsAny<TermsOfUse>())).Throws<Exception>();
var pc = new PackageManagerClient(gc.Object, MockMaker.Empty<IPackageUploadBuilder>(), "");
var res = pc.SetTermsOfUseAcceptanceStatus();
Assert.IsFalse(res);
}
