public virtual void TestInitFirstVerifyStopInvokedImmediately()
{
DefaultMetricsSystem.Shutdown();
new ConfigBuilder().Add("*.period", 8).Add("test.sink.test.class", typeof(TestMetricsSystemImpl.TestSink
).FullName).Add("test.*.source.filter.exclude", "s0").Add("test.source.s1.metric.filter.exclude"
, "X*").Add("test.sink.sink1.metric.filter.exclude", "Y*").Add("test.sink.sink2.metric.filter.exclude"
, "Y*").Save(TestMetricsConfig.GetTestFilename("hadoop-metrics2-test"));
//.add("test.sink.plugin.urls", getPluginUrlsAsString())
MetricsSystemImpl ms = new MetricsSystemImpl("Test");
ms.Start();
ms.Register("s0", "s0 desc", new TestMetricsSystemImpl.TestSource("s0rec"));
TestMetricsSystemImpl.TestSource s1 = ms.Register("s1", "s1 desc", new TestMetricsSystemImpl.TestSource
("s1rec"));
s1.c1.Incr();
s1.xxx.Incr();
s1.g1.Set(2);
s1.yyy.Incr(2);
s1.s1.Add(0);
MetricsSink sink1 = Org.Mockito.Mockito.Mock <MetricsSink>();
MetricsSink sink2 = Org.Mockito.Mockito.Mock <MetricsSink>();
ms.RegisterSink("sink1", "sink1 desc", sink1);
ms.RegisterSink("sink2", "sink2 desc", sink2);
ms.PublishMetricsNow();
// publish the metrics
ms.Stop();
ms.Shutdown();
//When we call stop, at most two sources will be consumed by each sink thread.
Org.Mockito.Mockito.Verify(sink1, Org.Mockito.Mockito.AtMost(2)).PutMetrics(r1.Capture
());
IList <MetricsRecord> mr1 = r1.GetAllValues();
Org.Mockito.Mockito.Verify(sink2, Org.Mockito.Mockito.AtMost(2)).PutMetrics(r2.Capture
());
IList <MetricsRecord> mr2 = r2.GetAllValues();
if (mr1.Count != 0 && mr2.Count != 0)
{
CheckMetricsRecords(mr1);
MoreAsserts.AssertEquals("output", mr1, mr2);
}
else
{
if (mr1.Count != 0)
{
CheckMetricsRecords(mr1);
}
else
{
if (mr2.Count != 0)
{
CheckMetricsRecords(mr2);
}
}
}
}
public virtual void TestTransitionToActive()
{
Org.Mockito.Mockito.DoReturn(StandbyReadyResult).When(mockProtocol).GetServiceStatus
();
NUnit.Framework.Assert.AreEqual(0, RunTool("-transitionToActive", "nn1"));
Org.Mockito.Mockito.Verify(mockProtocol).TransitionToActive(reqInfoCaptor.Capture
());
NUnit.Framework.Assert.AreEqual(HAServiceProtocol.RequestSource.RequestByUser, reqInfoCaptor
.GetValue().GetSource());
}
public virtual void TestPutMetrics2()
{
GraphiteSink sink = new GraphiteSink();
IList <MetricsTag> tags = new AList <MetricsTag>();
tags.AddItem(new MetricsTag(MsInfo.Context, "all"));
tags.AddItem(new MetricsTag(MsInfo.Hostname, null));
ICollection <AbstractMetric> metrics = new HashSet <AbstractMetric>();
metrics.AddItem(MakeMetric("foo1", 1));
metrics.AddItem(MakeMetric("foo2", 2));
MetricsRecord record = new MetricsRecordImpl(MsInfo.Context, (long)10000, tags, metrics
);
ArgumentCaptor <string> argument = ArgumentCaptor.ForClass <string>();
GraphiteSink.Graphite mockGraphite = MakeGraphite();
Whitebox.SetInternalState(sink, "graphite", mockGraphite);
sink.PutMetrics(record);
try
{
Org.Mockito.Mockito.Verify(mockGraphite).Write(argument.Capture());
}
catch (IOException e)
{
Runtime.PrintStackTrace(e);
}
string result = argument.GetValue();
Assert.Equal(true, result.Equals("null.all.Context.Context=all.foo1 1 10\n"
+ "null.all.Context.Context=all.foo2 2 10\n") || result.Equals("null.all.Context.Context=all.foo2 2 10\n"
+ "null.all.Context.Context=all.foo1 1 10\n"));
}
public virtual void TestStorageReportHasStorageTypeAndState()
{
// Make sure we are not testing with the default type, that would not
// be a very good test.
NUnit.Framework.Assert.AreNotSame(storageType, StorageType.Default);
NameNode nn = cluster.GetNameNode();
DataNode dn = cluster.GetDataNodes()[0];
// Insert a spy object for the NN RPC.
DatanodeProtocolClientSideTranslatorPB nnSpy = DataNodeTestUtils.SpyOnBposToNN(dn
, nn);
// Trigger a heartbeat so there is an interaction with the spy
// object.
DataNodeTestUtils.TriggerHeartbeat(dn);
// Verify that the callback passed in the expected parameters.
ArgumentCaptor <StorageReport[]> captor = ArgumentCaptor.ForClass <StorageReport[]>
();
Org.Mockito.Mockito.Verify(nnSpy).SendHeartbeat(Matchers.Any <DatanodeRegistration
>(), captor.Capture(), Matchers.AnyLong(), Matchers.AnyLong(), Matchers.AnyInt()
, Matchers.AnyInt(), Matchers.AnyInt(), Org.Mockito.Mockito.Any <VolumeFailureSummary
>());
StorageReport[] reports = captor.GetValue();
foreach (StorageReport report in reports)
{
Assert.AssertThat(report.GetStorage().GetStorageType(), IS.Is(storageType));
Assert.AssertThat(report.GetStorage().GetState(), IS.Is(DatanodeStorage.State.Normal
));
}
}
public async Task NewBrandCommandHandler_Works()
{
var repository = new Mock <IRepository>();
var brand = new Brand {
Id = 1, Name = "a", ImageUri = "uri"
};
var captor = new ArgumentCaptor <Brand>();
repository.Setup(x => x.InsertAsync(captor.Capture()))
.ReturnsAsync(brand);
var handler = new NewBrandCommandHandler(repository.Object);
var result = await handler
.Handle(new NewBrandCommand(brand.Name, brand.ImageUri), It.IsAny <CancellationToken>())
.ConfigureAwait(false);
result.Should().BeOfType <BrandDto>();
result.Id.Should().Equals(brand.Id);
result.ImageUri.Should().Equals(brand.ImageUri);
result.Name.Should().Equals(brand.Name);
captor.Value.Name.Should().Be(brand.Name);
captor.Value.ImageUri.Should().Be(brand.ImageUri);
repository.Verify(x => x.InsertAsync(captor.Value), Times.Once);
repository.VerifyNoOtherCalls();
}
public async Task NewRecordCommandHandler_Verify_Dependencies()
{
var repository = new Mock <IRepository>();
var record = GetRecord();
var flavors = new string[] { "a", "b", "c" };
var flavorPredicateCaptor = new ExpressionCaptor <Flavor, bool>();
repository.Setup(x => x.ListAsync(flavorPredicateCaptor.Capture()))
.ReturnsAsync(new List <Flavor> {
new Flavor {
Id = 1, Name = "a",
}
});
var recordCaptor = new ArgumentCaptor <Record>();
repository.Setup(x => x.InsertAsync(recordCaptor.Capture()))
.ReturnsAsync(record);
var flavorCaptor = new ArgumentCaptor <List <Flavor> >();
repository.Setup(x => x.InsertRangeAsync(flavorCaptor.Capture()))
.ReturnsAsync(
new List <Flavor> {
new Flavor {
Id = 2, Name = "b",
},
new Flavor {
Id = 3, Name = "c",
}
});
var recordFlavorCaptor = new ArgumentCaptor <List <RecordFlavor> >();
repository.Setup(x => x.InsertRangeAsync(recordFlavorCaptor.Capture()));
var handler = new NewRecordCommandHandler(repository.Object);
var result = await handler
.Handle(new NewRecordCommand(record.CoffeeId, record.DoseIn, record.DoseOut, record.Time, flavors, record.Rating),
It.IsAny <CancellationToken>())
.ConfigureAwait(false);
repository.Verify(x => x.InsertAsync(recordCaptor.Value), Times.Once);
repository.Verify(x => x.InsertRangeAsync(flavorCaptor.Value), Times.Once);
repository.Verify(x => x.InsertRangeAsync(recordFlavorCaptor.Value), Times.Once);
repository.Verify(x => x.ListAsync(flavorPredicateCaptor.Value), Times.Once);
repository.VerifyNoOtherCalls();
}
private void VerifyFailedStatus(MRAppMasterTest appMaster, string expectedJobState
)
{
ArgumentCaptor<JobHistoryEvent> captor = ArgumentCaptor.ForClass<JobHistoryEvent>
();
// handle two events: AMStartedEvent and JobUnsuccessfulCompletionEvent
Org.Mockito.Mockito.Verify(appMaster.spyHistoryService, Org.Mockito.Mockito.Times
(2)).HandleEvent(captor.Capture());
HistoryEvent @event = captor.GetValue().GetHistoryEvent();
NUnit.Framework.Assert.IsTrue(@event is JobUnsuccessfulCompletionEvent);
NUnit.Framework.Assert.AreEqual(((JobUnsuccessfulCompletionEvent)@event).GetStatus
(), expectedJobState);
}
public virtual void TestRecovery()
{
FilePath[] localLogDirs = GetLocalLogDirFiles(this.GetType().FullName, 2);
string localLogDirsString = localLogDirs[0].GetAbsolutePath() + "," + localLogDirs
[1].GetAbsolutePath();
conf.Set(YarnConfiguration.NmLogDirs, localLogDirsString);
conf.SetBoolean(YarnConfiguration.LogAggregationEnabled, false);
conf.SetLong(YarnConfiguration.NmLogRetainSeconds, YarnConfiguration.DefaultNmLogRetainSeconds
);
dirsHandler.Init(conf);
NMStateStoreService stateStore = new NMMemoryStateStoreService();
stateStore.Init(conf);
stateStore.Start();
TestNonAggregatingLogHandler.NonAggregatingLogHandlerWithMockExecutor logHandler =
new TestNonAggregatingLogHandler.NonAggregatingLogHandlerWithMockExecutor(this,
dispatcher, mockDelService, dirsHandler, stateStore);
logHandler.Init(conf);
logHandler.Start();
logHandler.Handle(new LogHandlerAppStartedEvent(appId, user, null, ContainerLogsRetentionPolicy
.AllContainers, null));
logHandler.Handle(new LogHandlerContainerFinishedEvent(container11, 0));
logHandler.Handle(new LogHandlerAppFinishedEvent(appId));
// simulate a restart and verify deletion is rescheduled
logHandler.Close();
logHandler = new TestNonAggregatingLogHandler.NonAggregatingLogHandlerWithMockExecutor
(this, dispatcher, mockDelService, dirsHandler, stateStore);
logHandler.Init(conf);
logHandler.Start();
ArgumentCaptor <Runnable> schedArg = ArgumentCaptor.ForClass <Runnable>();
Org.Mockito.Mockito.Verify(logHandler.mockSched).Schedule(schedArg.Capture(), Matchers.AnyLong
(), Matchers.Eq(TimeUnit.Milliseconds));
// execute the runnable and verify another restart has nothing scheduled
schedArg.GetValue().Run();
logHandler.Close();
logHandler = new TestNonAggregatingLogHandler.NonAggregatingLogHandlerWithMockExecutor
(this, dispatcher, mockDelService, dirsHandler, stateStore);
logHandler.Init(conf);
logHandler.Start();
Org.Mockito.Mockito.Verify(logHandler.mockSched, Org.Mockito.Mockito.Never()).Schedule
(Matchers.Any <Runnable>(), Matchers.AnyLong(), Matchers.Any <TimeUnit>());
logHandler.Close();
}
public virtual void TestCommon()
{
MetricsVisitor visitor = Org.Mockito.Mockito.Mock <MetricsVisitor>();
MetricsRegistry registry = new MetricsRegistry("test");
IList <AbstractMetric> metrics = ((MetricsRecordBuilderImpl)((MetricsRecordBuilderImpl
)((MetricsRecordBuilderImpl)((MetricsRecordBuilderImpl)((MetricsRecordBuilderImpl
)((MetricsRecordBuilderImpl)MetricsLists.Builder("test").AddCounter(Interns.Info
("c1", "int counter"), 1)).AddCounter(Interns.Info("c2", "long counter"), 2L)).AddGauge
(Interns.Info("g1", "int gauge"), 5)).AddGauge(Interns.Info("g2", "long gauge"),
6L)).AddGauge(Interns.Info("g3", "float gauge"), 7f)).AddGauge(Interns.Info("g4"
, "double gauge"), 8d)).Metrics();
foreach (AbstractMetric metric in metrics)
{
metric.Visit(visitor);
}
Org.Mockito.Mockito.Verify(visitor).Counter(c1.Capture(), Eq(1));
Assert.Equal("c1 name", "c1", c1.GetValue().Name());
Assert.Equal("c1 description", "int counter", c1.GetValue().Description
());
Org.Mockito.Mockito.Verify(visitor).Counter(c2.Capture(), Eq(2L));
Assert.Equal("c2 name", "c2", c2.GetValue().Name());
Assert.Equal("c2 description", "long counter", c2.GetValue().Description
());
Org.Mockito.Mockito.Verify(visitor).Gauge(g1.Capture(), Eq(5));
Assert.Equal("g1 name", "g1", g1.GetValue().Name());
Assert.Equal("g1 description", "int gauge", g1.GetValue().Description
());
Org.Mockito.Mockito.Verify(visitor).Gauge(g2.Capture(), Eq(6L));
Assert.Equal("g2 name", "g2", g2.GetValue().Name());
Assert.Equal("g2 description", "long gauge", g2.GetValue().Description
());
Org.Mockito.Mockito.Verify(visitor).Gauge(g3.Capture(), Eq(7f));
Assert.Equal("g3 name", "g3", g3.GetValue().Name());
Assert.Equal("g3 description", "float gauge", g3.GetValue().Description
());
Org.Mockito.Mockito.Verify(visitor).Gauge(g4.Capture(), Eq(8d));
Assert.Equal("g4 name", "g4", g4.GetValue().Name());
Assert.Equal("g4 description", "double gauge", g4.GetValue().Description
());
}
public virtual void TestFilter()
{
FilterConfig config = MockConfig("myuser");
StaticUserWebFilter.StaticUserFilter suf = new StaticUserWebFilter.StaticUserFilter
();
suf.Init(config);
ArgumentCaptor <HttpServletRequestWrapper> wrapperArg = ArgumentCaptor.ForClass <HttpServletRequestWrapper
>();
FilterChain chain = Org.Mockito.Mockito.Mock <FilterChain>();
suf.DoFilter(Org.Mockito.Mockito.Mock <HttpServletRequest>(), Org.Mockito.Mockito.Mock
<ServletResponse>(), chain);
Org.Mockito.Mockito.Verify(chain).DoFilter(wrapperArg.Capture(), Org.Mockito.Mockito
.AnyObject <ServletResponse>());
HttpServletRequestWrapper wrapper = wrapperArg.GetValue();
Assert.Equal("myuser", wrapper.GetUserPrincipal().GetName());
Assert.Equal("myuser", wrapper.GetRemoteUser());
suf.Destroy();
}
public void NowPlayingPlayFromIndex()
{
const string message = @"
{
""context"": ""nowplayinglistplay"",
""data"": 2
}
";
var socketMessage = new SocketMessage(JObject.Parse(message));
var messageEvent = new MessageEvent(
socketMessage.Context,
socketMessage.Data,
string.Empty,
"5");
_request.Execute(messageEvent);
_apiAdapter.Verify(adapter => adapter.PlayIndex(2));
var captor = new ArgumentCaptor <PluginResponseAvailableEvent>();
_hub.Verify(hub => hub.Publish(captor.Capture()));
Assert.AreEqual("nowplayinglistplay", captor.Value.Message.Context);
}
public virtual void TestGetRootQueues()
{
ApplicationClientProtocol applicationsManager = Org.Mockito.Mockito.Mock <ApplicationClientProtocol
>();
GetQueueInfoResponse response = Org.Mockito.Mockito.Mock <GetQueueInfoResponse>();
QueueInfo queueInfo = Org.Mockito.Mockito.Mock <QueueInfo>();
Org.Mockito.Mockito.When(response.GetQueueInfo()).ThenReturn(queueInfo);
try
{
Org.Mockito.Mockito.When(applicationsManager.GetQueueInfo(Org.Mockito.Mockito.Any
<GetQueueInfoRequest>())).ThenReturn(response);
}
catch (YarnException e)
{
throw new IOException(e);
}
ResourceMgrDelegate delegate_ = new _ResourceMgrDelegate_69(applicationsManager,
new YarnConfiguration());
delegate_.GetRootQueues();
ArgumentCaptor <GetQueueInfoRequest> argument = ArgumentCaptor.ForClass <GetQueueInfoRequest
>();
try
{
Org.Mockito.Mockito.Verify(applicationsManager).GetQueueInfo(argument.Capture());
}
catch (YarnException e)
{
throw new IOException(e);
}
NUnit.Framework.Assert.IsTrue("Children of root queue not requested", argument.GetValue
().GetIncludeChildQueues());
NUnit.Framework.Assert.IsTrue("Request wasn't to recurse through children", argument
.GetValue().GetRecursive());
}
/// <exception cref="System.IO.IOException"/>
private void RunTest(TestNNStorageRetentionManager.TestCaseDescription tc)
{
NNStorageRetentionManager.StoragePurger mockPurger = Org.Mockito.Mockito.Mock <NNStorageRetentionManager.StoragePurger
>();
ArgumentCaptor <FSImageStorageInspector.FSImageFile> imagesPurgedCaptor = ArgumentCaptor
.ForClass <FSImageStorageInspector.FSImageFile>();
ArgumentCaptor <FileJournalManager.EditLogFile> logsPurgedCaptor = ArgumentCaptor.
ForClass <FileJournalManager.EditLogFile>();
// Ask the manager to purge files we don't need any more
new NNStorageRetentionManager(conf, tc.MockStorage(), tc.MockEditLog(mockPurger),
mockPurger).PurgeOldStorage(NNStorage.NameNodeFile.Image);
// Verify that it asked the purger to remove the correct files
Org.Mockito.Mockito.Verify(mockPurger, Org.Mockito.Mockito.AtLeast(0)).PurgeImage
(imagesPurgedCaptor.Capture());
Org.Mockito.Mockito.Verify(mockPurger, Org.Mockito.Mockito.AtLeast(0)).PurgeLog(logsPurgedCaptor
.Capture());
// Check images
ICollection <string> purgedPaths = Sets.NewLinkedHashSet();
foreach (FSImageStorageInspector.FSImageFile purged in imagesPurgedCaptor.GetAllValues
())
{
purgedPaths.AddItem(FileToPath(purged.GetFile()));
}
NUnit.Framework.Assert.AreEqual(Joiner.On(",").Join(FilesToPaths(tc.expectedPurgedImages
)), Joiner.On(",").Join(purgedPaths));
// Check images
purgedPaths.Clear();
foreach (FileJournalManager.EditLogFile purged_1 in logsPurgedCaptor.GetAllValues
())
{
purgedPaths.AddItem(FileToPath(purged_1.GetFile()));
}
NUnit.Framework.Assert.AreEqual(Joiner.On(",").Join(FilesToPaths(tc.expectedPurgedLogs
)), Joiner.On(",").Join(purgedPaths));
}
public async Task NewCoffeeCommandHandler_Works()
{
var repository = new Mock <IRepository>();
var coffee = new Coffee
{
Id = 1,
BrandId = 1,
CoffeeType = Core.Enums.CoffeeType.Robusto,
Country = "a",
};
var captor = new ArgumentCaptor <Coffee>();
repository.Setup(x => x.InsertAsync(captor.Capture()))
.ReturnsAsync(coffee);
var handler = new NewCoffeeCommandHandler(repository.Object);
var result = await handler
.Handle(new NewCoffeeCommand(coffee.BrandId, coffee.CoffeeType.ToString(), coffee.Country),
It.IsAny <CancellationToken>())
.ConfigureAwait(false);
result.Should().BeOfType <CoffeeDto>();
result.Id.Should().Equals(coffee.Id);
result.CoffeeType.Should().Equals(coffee.CoffeeType);
result.Country.Should().Equals(coffee.Country);
captor.Value.BrandId.Should().Be(coffee.BrandId);
captor.Value.CoffeeType.Should().Be(coffee.CoffeeType);
captor.Value.Country.Should().Be(coffee.Country);
repository.Verify(x => x.InsertAsync(captor.Value), Times.Once);
repository.VerifyNoOtherCalls();
}
public virtual void TestFailureAndPutMetrics()
{
GraphiteSink sink = new GraphiteSink();
IList <MetricsTag> tags = new AList <MetricsTag>();
tags.AddItem(new MetricsTag(MsInfo.Context, "all"));
tags.AddItem(new MetricsTag(MsInfo.Hostname, "host"));
ICollection <AbstractMetric> metrics = new HashSet <AbstractMetric>();
metrics.AddItem(MakeMetric("foo1", 1.25));
metrics.AddItem(MakeMetric("foo2", 2.25));
MetricsRecord record = new MetricsRecordImpl(MsInfo.Context, (long)10000, tags, metrics
);
GraphiteSink.Graphite mockGraphite = MakeGraphite();
Whitebox.SetInternalState(sink, "graphite", mockGraphite);
// throw exception when first try
Org.Mockito.Mockito.DoThrow(new IOException("IO exception")).When(mockGraphite).Write
(Matchers.AnyString());
sink.PutMetrics(record);
Org.Mockito.Mockito.Verify(mockGraphite).Write(Matchers.AnyString());
Org.Mockito.Mockito.Verify(mockGraphite).Close();
// reset mock and try again
Org.Mockito.Mockito.Reset(mockGraphite);
Org.Mockito.Mockito.When(mockGraphite.IsConnected()).ThenReturn(false);
ArgumentCaptor <string> argument = ArgumentCaptor.ForClass <string>();
sink.PutMetrics(record);
Org.Mockito.Mockito.Verify(mockGraphite).Write(argument.Capture());
string result = argument.GetValue();
Assert.Equal(true, result.Equals("null.all.Context.Context=all.Hostname=host.foo1 1.25 10\n"
+ "null.all.Context.Context=all.Hostname=host.foo2 2.25 10\n") || result.Equals
("null.all.Context.Context=all.Hostname=host.foo2 2.25 10\n" + "null.all.Context.Context=all.Hostname=host.foo1 1.25 10\n"
));
}
/// <summary>
/// Test that if splitThreshold is zero, then we always get a separate
/// call per storage.
/// </summary>
/// <exception cref="System.IO.IOException"/>
/// <exception cref="System.Exception"/>
public virtual void TestAlwaysSplit()
{
StartUpCluster(0);
NameNode nn = cluster.GetNameNode();
DataNode dn = cluster.GetDataNodes()[0];
// Create a file with a few blocks.
CreateFile(GenericTestUtils.GetMethodName(), BlocksInFile);
// Insert a spy object for the NN RPC.
DatanodeProtocolClientSideTranslatorPB nnSpy = DataNodeTestUtils.SpyOnBposToNN(dn
, nn);
// Trigger a block report so there is an interaction with the spy
// object.
DataNodeTestUtils.TriggerBlockReport(dn);
ArgumentCaptor <StorageBlockReport[]> captor = ArgumentCaptor.ForClass <StorageBlockReport
[]>();
Org.Mockito.Mockito.Verify(nnSpy, Org.Mockito.Mockito.Times(cluster.GetStoragesPerDatanode
())).BlockReport(Matchers.Any <DatanodeRegistration>(), Matchers.AnyString(), captor
.Capture(), Org.Mockito.Mockito.AnyObject <BlockReportContext>());
VerifyCapturedArguments(captor, 1, BlocksInFile);
}
public virtual void TestReleaseWhileRunning()
{
DrainDispatcher drainDispatcher = new DrainDispatcher();
EventHandler <RMAppAttemptEvent> appAttemptEventHandler = Org.Mockito.Mockito.Mock
<EventHandler>();
EventHandler generic = Org.Mockito.Mockito.Mock <EventHandler>();
drainDispatcher.Register(typeof(RMAppAttemptEventType), appAttemptEventHandler);
drainDispatcher.Register(typeof(RMNodeEventType), generic);
drainDispatcher.Init(new YarnConfiguration());
drainDispatcher.Start();
NodeId nodeId = BuilderUtils.NewNodeId("host", 3425);
ApplicationId appId = BuilderUtils.NewApplicationId(1, 1);
ApplicationAttemptId appAttemptId = BuilderUtils.NewApplicationAttemptId(appId, 1
);
ContainerId containerId = BuilderUtils.NewContainerId(appAttemptId, 1);
ContainerAllocationExpirer expirer = Org.Mockito.Mockito.Mock <ContainerAllocationExpirer
>();
Resource resource = BuilderUtils.NewResource(512, 1);
Priority priority = BuilderUtils.NewPriority(5);
Container container = BuilderUtils.NewContainer(containerId, nodeId, "host:3465",
resource, priority, null);
ConcurrentMap <ApplicationId, RMApp> rmApps = Org.Mockito.Mockito.Spy(new ConcurrentHashMap
<ApplicationId, RMApp>());
RMApp rmApp = Org.Mockito.Mockito.Mock <RMApp>();
Org.Mockito.Mockito.When(rmApp.GetRMAppAttempt((ApplicationAttemptId)Matchers.Any
())).ThenReturn(null);
Org.Mockito.Mockito.DoReturn(rmApp).When(rmApps)[(ApplicationId)Matchers.Any()];
RMApplicationHistoryWriter writer = Org.Mockito.Mockito.Mock <RMApplicationHistoryWriter
>();
SystemMetricsPublisher publisher = Org.Mockito.Mockito.Mock <SystemMetricsPublisher
>();
RMContext rmContext = Org.Mockito.Mockito.Mock <RMContext>();
Org.Mockito.Mockito.When(rmContext.GetDispatcher()).ThenReturn(drainDispatcher);
Org.Mockito.Mockito.When(rmContext.GetContainerAllocationExpirer()).ThenReturn(expirer
);
Org.Mockito.Mockito.When(rmContext.GetRMApplicationHistoryWriter()).ThenReturn(writer
);
Org.Mockito.Mockito.When(rmContext.GetRMApps()).ThenReturn(rmApps);
Org.Mockito.Mockito.When(rmContext.GetSystemMetricsPublisher()).ThenReturn(publisher
);
Org.Mockito.Mockito.When(rmContext.GetYarnConfiguration()).ThenReturn(new YarnConfiguration
());
RMContainer rmContainer = new RMContainerImpl(container, appAttemptId, nodeId, "user"
, rmContext);
NUnit.Framework.Assert.AreEqual(RMContainerState.New, rmContainer.GetState());
NUnit.Framework.Assert.AreEqual(resource, rmContainer.GetAllocatedResource());
NUnit.Framework.Assert.AreEqual(nodeId, rmContainer.GetAllocatedNode());
NUnit.Framework.Assert.AreEqual(priority, rmContainer.GetAllocatedPriority());
Org.Mockito.Mockito.Verify(writer).ContainerStarted(Matchers.Any <RMContainer>());
Org.Mockito.Mockito.Verify(publisher).ContainerCreated(Matchers.Any <RMContainer>(
), Matchers.AnyLong());
rmContainer.Handle(new RMContainerEvent(containerId, RMContainerEventType.Start));
drainDispatcher.Await();
NUnit.Framework.Assert.AreEqual(RMContainerState.Allocated, rmContainer.GetState(
));
rmContainer.Handle(new RMContainerEvent(containerId, RMContainerEventType.Acquired
));
drainDispatcher.Await();
NUnit.Framework.Assert.AreEqual(RMContainerState.Acquired, rmContainer.GetState()
);
rmContainer.Handle(new RMContainerEvent(containerId, RMContainerEventType.Launched
));
drainDispatcher.Await();
NUnit.Framework.Assert.AreEqual(RMContainerState.Running, rmContainer.GetState());
NUnit.Framework.Assert.AreEqual("http://host:3465/node/containerlogs/container_1_0001_01_000001/user"
, rmContainer.GetLogURL());
// In RUNNING state. Verify RELEASED and associated actions.
Org.Mockito.Mockito.Reset(appAttemptEventHandler);
ContainerStatus containerStatus = SchedulerUtils.CreateAbnormalContainerStatus(containerId
, SchedulerUtils.ReleasedContainer);
rmContainer.Handle(new RMContainerFinishedEvent(containerId, containerStatus, RMContainerEventType
.Released));
drainDispatcher.Await();
NUnit.Framework.Assert.AreEqual(RMContainerState.Released, rmContainer.GetState()
);
NUnit.Framework.Assert.AreEqual(SchedulerUtils.ReleasedContainer, rmContainer.GetDiagnosticsInfo
());
NUnit.Framework.Assert.AreEqual(ContainerExitStatus.Aborted, rmContainer.GetContainerExitStatus
());
NUnit.Framework.Assert.AreEqual(ContainerState.Complete, rmContainer.GetContainerState
());
Org.Mockito.Mockito.Verify(writer).ContainerFinished(Matchers.Any <RMContainer>());
Org.Mockito.Mockito.Verify(publisher).ContainerFinished(Matchers.Any <RMContainer>
(), Matchers.AnyLong());
ArgumentCaptor <RMAppAttemptContainerFinishedEvent> captor = ArgumentCaptor.ForClass
<RMAppAttemptContainerFinishedEvent>();
Org.Mockito.Mockito.Verify(appAttemptEventHandler).Handle(captor.Capture());
RMAppAttemptContainerFinishedEvent cfEvent = captor.GetValue();
NUnit.Framework.Assert.AreEqual(appAttemptId, cfEvent.GetApplicationAttemptId());
NUnit.Framework.Assert.AreEqual(containerStatus, cfEvent.GetContainerStatus());
NUnit.Framework.Assert.AreEqual(RMAppAttemptEventType.ContainerFinished, cfEvent.
GetType());
// In RELEASED state. A FINIHSED event may come in.
rmContainer.Handle(new RMContainerFinishedEvent(containerId, SchedulerUtils.CreateAbnormalContainerStatus
(containerId, "FinishedContainer"), RMContainerEventType.Finished));
NUnit.Framework.Assert.AreEqual(RMContainerState.Released, rmContainer.GetState()
);
}
public async Task NewRecordCommandHandler_Verify_Expressions()
{
var repository = new Mock <IRepository>();
var record = GetRecord();
var flavors = new string[] { "a", "b", "c" };
var flavorPredicateCaptor = new ExpressionCaptor <Flavor, bool>();
repository.Setup(x => x.ListAsync(flavorPredicateCaptor.Capture()))
.ReturnsAsync(new List <Flavor> {
new Flavor {
Id = 1, Name = "a",
}
});
var recordCaptor = new ArgumentCaptor <Record>();
repository.Setup(x => x.InsertAsync(recordCaptor.Capture()))
.ReturnsAsync(record);
var insertFlavorCaptor = new ArgumentCaptor <List <Flavor> >();
repository.Setup(x => x.InsertRangeAsync(insertFlavorCaptor.Capture()))
.ReturnsAsync(
new List <Flavor> {
new Flavor {
Id = 2, Name = "b",
},
new Flavor {
Id = 3, Name = "c",
}
});
var recordFlavorCaptor = new ArgumentCaptor <List <RecordFlavor> >();
repository.Setup(x => x.InsertRangeAsync(recordFlavorCaptor.Capture()));
var handler = new NewRecordCommandHandler(repository.Object);
var result = await handler
.Handle(new NewRecordCommand(record.CoffeeId, record.DoseIn, record.DoseOut, record.Time, flavors, record.Rating),
It.IsAny <CancellationToken>())
.ConfigureAwait(false);
var existingFlavors = new List <Flavor> {
new Flavor {
Name = "a"
}, new Flavor {
Name = "d"
}, new Flavor {
Name = "e"
},
};
var queriedFlavors = existingFlavors.Where(flavorPredicateCaptor.Compile());
queriedFlavors.Select(x => x.Name).Should().Equal("a");
recordCaptor.Value.CoffeeId.Should().Be(record.CoffeeId);
recordCaptor.Value.DoseIn.Should().Be(record.DoseIn);
recordCaptor.Value.DoseOut.Should().Be(record.DoseOut);
recordCaptor.Value.Time.Should().Be(record.Time);
insertFlavorCaptor.Value.Select(x => x.Name).Should().Equal("b", "c");
recordFlavorCaptor
.Value
.Select(x => (x.FlavorId, x.RecordId))
.Should().Equal(
new List <(long, long)>
{
(1, 1),
(2, 1),
(3, 1)
});
public static long GetLongCounter(string name, MetricsRecordBuilder rb)
{
ArgumentCaptor <long> captor = ArgumentCaptor.ForClass <long>();
Org.Mockito.Mockito.Verify(rb, Org.Mockito.Mockito.AtLeast(0)).AddCounter(EqName(
Interns.Info(name, string.Empty)), captor.Capture());
CheckCaptured(captor, name);
return(captor.GetValue());
}
public static float GetFloatGauge(string name, MetricsRecordBuilder rb)
{
ArgumentCaptor <float> captor = ArgumentCaptor.ForClass <float>();
Org.Mockito.Mockito.Verify(rb, Org.Mockito.Mockito.AtLeast(0)).AddGauge(EqName(Interns.Info
(name, string.Empty)), captor.Capture());
CheckCaptured(captor, name);
return(captor.GetValue());
}
/// <exception cref="System.Exception"/>
public virtual void TestContainerCleaned()
{
Log.Info("STARTING testContainerCleaned");
CyclicBarrier startLaunchBarrier = new CyclicBarrier(2);
CyclicBarrier completeLaunchBarrier = new CyclicBarrier(2);
AppContext mockContext = Org.Mockito.Mockito.Mock <AppContext>();
EventHandler mockEventHandler = Org.Mockito.Mockito.Mock <EventHandler>();
Org.Mockito.Mockito.When(mockContext.GetEventHandler()).ThenReturn(mockEventHandler
);
TestContainerLauncherImpl.ContainerManagementProtocolClient mockCM = new TestContainerLauncherImpl.ContainerManagerForTest
(startLaunchBarrier, completeLaunchBarrier);
TestContainerLauncherImpl.ContainerLauncherImplUnderTest ut = new TestContainerLauncherImpl.ContainerLauncherImplUnderTest
(mockContext, mockCM);
Configuration conf = new Configuration();
ut.Init(conf);
ut.Start();
try
{
ContainerId contId = MakeContainerId(0l, 0, 0, 1);
TaskAttemptId taskAttemptId = MakeTaskAttemptId(0l, 0, 0, TaskType.Map, 0);
string cmAddress = "127.0.0.1:8000";
StartContainersResponse startResp = recordFactory.NewRecordInstance <StartContainersResponse
>();
startResp.SetAllServicesMetaData(serviceResponse);
Log.Info("inserting launch event");
ContainerRemoteLaunchEvent mockLaunchEvent = Org.Mockito.Mockito.Mock <ContainerRemoteLaunchEvent
>();
Org.Mockito.Mockito.When(mockLaunchEvent.GetType()).ThenReturn(ContainerLauncher.EventType
.ContainerRemoteLaunch);
Org.Mockito.Mockito.When(mockLaunchEvent.GetContainerID()).ThenReturn(contId);
Org.Mockito.Mockito.When(mockLaunchEvent.GetTaskAttemptID()).ThenReturn(taskAttemptId
);
Org.Mockito.Mockito.When(mockLaunchEvent.GetContainerMgrAddress()).ThenReturn(cmAddress
);
Org.Mockito.Mockito.When(mockLaunchEvent.GetContainerToken()).ThenReturn(CreateNewContainerToken
(contId, cmAddress));
ut.Handle(mockLaunchEvent);
startLaunchBarrier.Await();
Log.Info("inserting cleanup event");
ContainerLauncherEvent mockCleanupEvent = Org.Mockito.Mockito.Mock <ContainerLauncherEvent
>();
Org.Mockito.Mockito.When(mockCleanupEvent.GetType()).ThenReturn(ContainerLauncher.EventType
.ContainerRemoteCleanup);
Org.Mockito.Mockito.When(mockCleanupEvent.GetContainerID()).ThenReturn(contId);
Org.Mockito.Mockito.When(mockCleanupEvent.GetTaskAttemptID()).ThenReturn(taskAttemptId
);
Org.Mockito.Mockito.When(mockCleanupEvent.GetContainerMgrAddress()).ThenReturn(cmAddress
);
ut.Handle(mockCleanupEvent);
completeLaunchBarrier.Await();
ut.WaitForPoolToIdle();
ArgumentCaptor <Org.Apache.Hadoop.Yarn.Event.Event> arg = ArgumentCaptor.ForClass <
Org.Apache.Hadoop.Yarn.Event.Event>();
Org.Mockito.Mockito.Verify(mockEventHandler, Org.Mockito.Mockito.AtLeast(2)).Handle
(arg.Capture());
bool containerCleaned = false;
for (int i = 0; i < arg.GetAllValues().Count; i++)
{
Log.Info(arg.GetAllValues()[i].ToString());
Org.Apache.Hadoop.Yarn.Event.Event currentEvent = arg.GetAllValues()[i];
if (currentEvent.GetType() == TaskAttemptEventType.TaContainerCleaned)
{
containerCleaned = true;
}
}
System.Diagnostics.Debug.Assert((containerCleaned));
}
finally
{
ut.Stop();
}
}
public virtual void TestRsrcUnused()
{
DeletionService delService = Org.Mockito.Mockito.Mock <DeletionService>();
long TargetMb = 10 << 20;
ResourceRetentionSet rss = new ResourceRetentionSet(delService, TargetMb);
// 3MB files @{10, 15}
LocalResourcesTracker pubTracker = CreateMockTracker(null, 3 * 1024 * 1024, 2, 10
, 5);
// 1MB files @{3, 6, 9, 12}
LocalResourcesTracker trackerA = CreateMockTracker("A", 1 * 1024 * 1024, 4, 3, 3);
// 4MB file @{1}
LocalResourcesTracker trackerB = CreateMockTracker("B", 4 * 1024 * 1024, 1, 10, 5
);
// 2MB files @{7, 9, 11}
LocalResourcesTracker trackerC = CreateMockTracker("C", 2 * 1024 * 1024, 3, 7, 2);
// Total cache: 20MB; verify removed at least 10MB
rss.AddResources(pubTracker);
rss.AddResources(trackerA);
rss.AddResources(trackerB);
rss.AddResources(trackerC);
long deleted = 0L;
ArgumentCaptor <LocalizedResource> captor = ArgumentCaptor.ForClass <LocalizedResource
>();
Org.Mockito.Mockito.Verify(pubTracker, Org.Mockito.Mockito.AtMost(2)).Remove(captor
.Capture(), IsA <DeletionService>());
Org.Mockito.Mockito.Verify(trackerA, Org.Mockito.Mockito.AtMost(4)).Remove(captor
.Capture(), IsA <DeletionService>());
Org.Mockito.Mockito.Verify(trackerB, Org.Mockito.Mockito.AtMost(1)).Remove(captor
.Capture(), IsA <DeletionService>());
Org.Mockito.Mockito.Verify(trackerC, Org.Mockito.Mockito.AtMost(3)).Remove(captor
.Capture(), IsA <DeletionService>());
foreach (LocalizedResource rem in captor.GetAllValues())
{
deleted += rem.GetSize();
}
NUnit.Framework.Assert.IsTrue(deleted >= 10 * 1024 * 1024);
NUnit.Framework.Assert.IsTrue(deleted < 15 * 1024 * 1024);
}