public void DsfDropBoxDeleteActivity_PerformExecution_DropboxUploadSuccessResult_GivenPaths_ExpectException()
{
//---------------Set up test pack-------------------
var mockExecutor = new Mock <IDropboxSingleExecutor <IDropboxResult> >();
var dropboxClient = new Mock <IDropboxClient>();
Task <Metadata> value = null;
dropboxClient.Setup(wrapper => wrapper.UploadAsync(It.IsAny <string>(), It.IsAny <WriteMode>(), It.IsAny <bool>(), null, It.IsAny <bool>(), It.IsAny <MemoryStream>()))
.Returns(Task.FromResult(TestConstant.FileMetadataInstance.Value));
dropboxClient.Setup(wrapper => wrapper.DeleteAsync(It.IsAny <string>())).Returns(value);
mockExecutor.Setup(executor => executor.ExecuteTask(dropboxClient.Object))
.Returns(new DropboxUploadSuccessResult(TestConstant.FileMetadataInstance.Value));
var dsfDropBoxDeleteAcivtityMock = new DsfDropBoxDeleteActivityMock(mockExecutor.Object, dropboxClient.Object)
{
IsUplodValidSuccess = true,
SelectedSource = new DropBoxSource()
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfDropBoxDeleteAcivtityMock);
//---------------Execute Test ----------------------
var location = Assembly.GetExecutingAssembly().Location;
var listPerfomBaseExecution = dsfDropBoxDeleteAcivtityMock.PerfomBaseExecution(new Dictionary <string, string>
{
{ "DeletePath", location },
});
//---------------Test Result -----------------------
}
public void DsfDropBoxDeleteActivity_ExecuteTool_GivenNoToPath_ShouldAddError()
{
//---------------Set up test pack-------------------
var mockExecutor = new Mock <IDropboxSingleExecutor <IDropboxResult> >();
var dropboxClient = new Mock <IDropboxClient>();
mockExecutor.Setup(executor => executor.ExecuteTask(TestConstant.DropboxClientInstance.Value))
.Returns(new DropboxUploadSuccessResult(TestConstant.FileMetadataInstance.Value));
var dsfDropBoxDeleteAcivtityMock = new DsfDropBoxDeleteActivityMock(mockExecutor.Object, dropboxClient.Object)
{
IsUplodValidSuccess = true,
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfDropBoxDeleteAcivtityMock);
//---------------Execute Test ----------------------
var datObj = new Mock <IDSFDataObject>();
var executionEnvironment = new Mock <IExecutionEnvironment>();
datObj.Setup(o => o.Environment).Returns(executionEnvironment.Object);
var dataObject = datObj.Object;
dsfDropBoxDeleteAcivtityMock.Execute(dataObject, 0);
//---------------Test Result -----------------------
datObj.VerifyAll();
}
public void DsfDropBoxDeleteActivity_DropBoxSource_Same_Object_Is_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var mockDropboxClient = new Mock <IDropboxClient>();
var mockDropboxClientFactory = new Mock <IDropboxClientFactory>();
mockDropboxClientFactory.Setup(o => o.New(It.IsAny <string>(), It.IsAny <HttpClient>())).Returns(mockDropboxClient.Object);
using (var dropBoxDeleteActivity = new DsfDropBoxDeleteActivityMock(mockDropboxClientFactory.Object)
{
UniqueID = uniqueId,
Result = "A"
})
{
dropBoxDeleteActivity.SetupDropboxClient("");
var dropBoxDeleteActivity1 = new DsfDropBoxDeleteActivity {
UniqueID = uniqueId, Result = "A"
};
//---------------Assert Precondition----------------
Assert.IsTrue(dropBoxDeleteActivity.Equals(dropBoxDeleteActivity1));
//---------------Execute Test ----------------------
dropBoxDeleteActivity.SelectedSource = new DropBoxSource();
dropBoxDeleteActivity1.SelectedSource = new DropBoxSource();
var @equals = dropBoxDeleteActivity.Equals(dropBoxDeleteActivity1);
//---------------Test Result -----------------------
Assert.IsTrue(equals);
}
}
public void DsfDropBoxDeleteActivity_Equals_IsNull_ExpectFalse()
{
//-----------------------Arrange----------------------------
var mockDropboxClient = new Mock <IDropboxClient>();
var mockDropboxClientFactory = new Mock <IDropboxClientFactory>();
mockDropboxClientFactory.Setup(o => o.New(It.IsAny <string>(), It.IsAny <HttpClient>())).Returns(mockDropboxClient.Object);
using (var dsfDropBoxDeleteAcivtity = new DsfDropBoxDeleteActivityMock(mockDropboxClientFactory.Object))
{
dsfDropBoxDeleteAcivtity.SetupDropboxClient("");
//-----------------------Act--------------------------------
//-----------------------Assert-----------------------------
Assert.IsFalse(dsfDropBoxDeleteAcivtity.Equals(null));
}
}
public void DsfDropBoxDeleteActivity_GetFindMissingType_ExpectStaticActivity()
{
//---------------Set up test pack-------------------
var mockExecutor = new Mock <IDropboxSingleExecutor <IDropboxResult> >();
var dropboxClient = new Mock <IDropboxClient>();
var dsfDropBoxDeleteAcivtityMock = new DsfDropBoxDeleteActivityMock(mockExecutor.Object, dropboxClient.Object)
{
IsUplodValidSuccess = true,
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfDropBoxDeleteAcivtityMock);
//---------------Execute Test ----------------------
//---------------Test Result -----------------------
Assert.AreEqual(enFindMissingType.StaticActivity, dsfDropBoxDeleteAcivtityMock.GetFindMissingType());
}
public void DsfDropBoxDeleteActivity_GetHashCode_Properties_IsNull_ExpertTrue()
{
//--------------------------Arrange----------------------------
var mockDropboxClient = new Mock <IDropboxClient>();
var mockDropboxClientFactory = new Mock <IDropboxClientFactory>();
mockDropboxClientFactory.Setup(o => o.New(It.IsAny <string>(), It.IsAny <HttpClient>())).Returns(mockDropboxClient.Object);
using (var dsfDropBoxDeleteAcivtity = new DsfDropBoxDeleteActivityMock(mockDropboxClientFactory.Object))
{
dsfDropBoxDeleteAcivtity.SetupDropboxClient("");
//--------------------------Act--------------------------------
var getHash = dsfDropBoxDeleteAcivtity.GetHashCode();
//--------------------------Assert-----------------------------
Assert.IsNotNull(getHash);
}
}
public void DsfDropBoxDeleteActivity_PerformExecution_GivenNoPaths_ShouldThrowException()
{
//---------------Set up test pack-------------------
var mockExecutor = new Mock <IDropboxSingleExecutor <IDropboxResult> >();
var dropboxClient = new Mock <IDropboxClient>();
mockExecutor.Setup(executor => executor.ExecuteTask(TestConstant.DropboxClientInstance.Value))
.Returns(new DropboxUploadSuccessResult(TestConstant.FileMetadataInstance.Value));
var dsfDropBoxUploadAcivtityMock = new DsfDropBoxDeleteActivityMock(mockExecutor.Object, dropboxClient.Object)
{
IsUplodValidSuccess = true
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfDropBoxUploadAcivtityMock);
//---------------Execute Test ----------------------
dsfDropBoxUploadAcivtityMock.PerfomBaseExecution(new Dictionary <string, string>());
//---------------Test Result -----------------------
}
public void DsfDropBoxDeleteActivity_GetState_ReturnsStateVariable()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid();
var selectedSource = new MockOAuthSource(uniqueId);
var mockDropboxClient = new Mock <IDropboxClient>();
var mockDropboxClientFactory = new Mock <IDropboxClientFactory>();
mockDropboxClientFactory.Setup(o => o.New(It.IsAny <string>(), It.IsAny <HttpClient>())).Returns(mockDropboxClient.Object);
//------------Setup for test--------------------------
using (var dropBoxDeleteActivity = new DsfDropBoxDeleteActivityMock(mockDropboxClientFactory.Object)
{
SelectedSource = selectedSource, DeletePath = "Path", Result = "Deleted"
})
{
dropBoxDeleteActivity.SetupDropboxClient("");
{
//------------Execute Test---------------------------
var stateItems = dropBoxDeleteActivity.GetState();
Assert.AreEqual(3, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "SelectedSource.ResourceID",
Type = StateVariable.StateType.Input,
Value = uniqueId.ToString()
},
new StateVariable
{
Name = "DeletePath",
Type = StateVariable.StateType.Input,
Value = "Path"
},
new StateVariable
{
Name = "Result",
Type = StateVariable.StateType.Output,
Value = "Deleted"
}
};
var iter = dropBoxDeleteActivity.GetState().Select(
(item, index) => new
{
value = item,
expectValue = expectedResults[index]
}
);
//------------Assert Results-------------------------
foreach (var entry in iter)
{
Assert.AreEqual(entry.expectValue.Name, entry.value.Name);
Assert.AreEqual(entry.expectValue.Type, entry.value.Type);
Assert.AreEqual(entry.expectValue.Value, entry.value.Value);
}
}
}
}
