method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
DisableAppService { public void remove(final String appName) { regCenter.remove(DisableAppNode.getDisableAppNodePath(appName)); } DisableAppService(final CoordinatorRegistryCenter regCenter); void add(final String appName); void remove(final String appName); boolean isDisabled(final String appName); }### Answer:
@Test public void assertRemove() { disableAppService.remove("test_app"); Mockito.verify(regCenter).remove("/state/disable/app/test_app"); }
@Test public void assertRemove() { disableAppService.remove("test_app"); verify(regCenter).remove("/state/disable/app/test_app"); }
|
### Question:
CloudJobFacade implements JobFacade { @Override public void postJobStatusTraceEvent(final String taskId, final JobStatusTraceEvent.State state, final String message) { TaskContext taskContext = TaskContext.from(taskId); jobEventBus.post(new JobStatusTraceEvent(taskContext.getMetaInfo().getJobName(), taskContext.getId(), taskContext.getSlaveId(), JobStatusTraceEvent.Source.CLOUD_EXECUTOR, taskContext.getType(), String.valueOf(taskContext.getMetaInfo().getShardingItems()), state, message)); } @Override JobRootConfiguration loadJobRootConfiguration(final boolean fromCache); @Override void checkJobExecutionEnvironment(); @Override void failoverIfNecessary(); @Override void registerJobBegin(final ShardingContexts shardingContexts); @Override void registerJobCompleted(final ShardingContexts shardingContexts); ShardingContexts getShardingContexts(); @Override boolean misfireIfRunning(final Collection<Integer> shardingItems); @Override void clearMisfire(final Collection<Integer> shardingItems); @Override boolean isExecuteMisfired(final Collection<Integer> shardingItems); @Override boolean isEligibleForJobRunning(); @Override boolean isNeedSharding(); @Override void beforeJobExecuted(final ShardingContexts shardingContexts); @Override void afterJobExecuted(final ShardingContexts shardingContexts); @Override void postJobExecutionEvent(final JobExecutionEvent jobExecutionEvent); @Override void postJobStatusTraceEvent(final String taskId, final JobStatusTraceEvent.State state, final String message); }### Answer:
@Test public void assertPostJobStatusTraceEvent() { jobFacade.postJobStatusTraceEvent(String.format("%s@-@0@-@%s@-@fake_slave_id@-@0", "test_job", ExecutionType.READY), JobStatusTraceEvent.State.TASK_RUNNING, "message is empty."); }
|
### Question:
DisableAppService { public boolean isDisabled(final String appName) { return regCenter.isExisted(DisableAppNode.getDisableAppNodePath(appName)); } DisableAppService(final CoordinatorRegistryCenter regCenter); void add(final String appName); void remove(final String appName); boolean isDisabled(final String appName); }### Answer:
@Test public void assertIsDisabled() { Mockito.when(regCenter.isExisted("/state/disable/app/test_app")).thenReturn(true); Assert.assertTrue(disableAppService.isDisabled("test_app")); Mockito.verify(regCenter).isExisted("/state/disable/app/test_app"); }
@Test public void assertIsEnabled() { Mockito.when(regCenter.isExisted("/state/disable/app/test_app")).thenReturn(false); Assert.assertFalse(disableAppService.isDisabled("test_app")); Mockito.verify(regCenter).isExisted("/state/disable/app/test_app"); }
@Test public void assertIsDisabled() { when(regCenter.isExisted("/state/disable/app/test_app")).thenReturn(true); assertTrue(disableAppService.isDisabled("test_app")); verify(regCenter).isExisted("/state/disable/app/test_app"); }
@Test public void assertIsEnabled() { when(regCenter.isExisted("/state/disable/app/test_app")).thenReturn(false); assertFalse(disableAppService.isDisabled("test_app")); verify(regCenter).isExisted("/state/disable/app/test_app"); }
|
### Question:
DisableJobNode { static String getDisableJobNodePath(final String jobName) { return String.format(DISABLE_JOB, jobName); } }### Answer:
@Test public void assertGetDisableAppNodePath() { Assert.assertThat(DisableJobNode.getDisableJobNodePath("test_job0000000001"), Is.is("/state/disable/job/test_job0000000001")); }
@Test public void assertGetDisableAppNodePath() { assertThat(DisableJobNode.getDisableJobNodePath("test_job0000000001"), is("/state/disable/job/test_job0000000001")); }
|
### Question:
DisableJobService { public void add(final String jobName) { if (regCenter.getNumChildren(DisableJobNode.ROOT) > env.getFrameworkConfiguration().getJobStateQueueSize()) { log.warn("Cannot add disable job, caused by read state queue size is larger than {}.", env.getFrameworkConfiguration().getJobStateQueueSize()); return; } String disableJobNodePath = DisableJobNode.getDisableJobNodePath(jobName); if (!regCenter.isExisted(disableJobNodePath)) { regCenter.persist(disableJobNodePath, jobName); } } DisableJobService(final CoordinatorRegistryCenter regCenter); void add(final String jobName); void remove(final String jobName); boolean isDisabled(final String jobName); }### Answer:
@Test public void assertAdd() { disableJobService.add("test_job"); Mockito.verify(regCenter).isExisted("/state/disable/job/test_job"); Mockito.verify(regCenter).persist("/state/disable/job/test_job", "test_job"); }
@Test public void assertAdd() { disableJobService.add("test_job"); verify(regCenter).isExisted("/state/disable/job/test_job"); verify(regCenter).persist("/state/disable/job/test_job", "test_job"); }
|
### Question:
DisableJobService { public void remove(final String jobName) { regCenter.remove(DisableJobNode.getDisableJobNodePath(jobName)); } DisableJobService(final CoordinatorRegistryCenter regCenter); void add(final String jobName); void remove(final String jobName); boolean isDisabled(final String jobName); }### Answer:
@Test public void assertRemove() { disableJobService.remove("test_job"); Mockito.verify(regCenter).remove("/state/disable/job/test_job"); }
@Test public void assertRemove() { disableJobService.remove("test_job"); verify(regCenter).remove("/state/disable/job/test_job"); }
|
### Question:
DisableJobService { public boolean isDisabled(final String jobName) { return regCenter.isExisted(DisableJobNode.getDisableJobNodePath(jobName)); } DisableJobService(final CoordinatorRegistryCenter regCenter); void add(final String jobName); void remove(final String jobName); boolean isDisabled(final String jobName); }### Answer:
@Test public void assertIsDisabled() { Mockito.when(regCenter.isExisted("/state/disable/job/test_job")).thenReturn(true); Assert.assertTrue(disableJobService.isDisabled("test_job")); Mockito.verify(regCenter).isExisted("/state/disable/job/test_job"); }
@Test public void assertIsEnabled() { Mockito.when(regCenter.isExisted("/state/disable/job/test_job")).thenReturn(false); Assert.assertFalse(disableJobService.isDisabled("test_job")); Mockito.verify(regCenter).isExisted("/state/disable/job/test_job"); }
@Test public void assertIsDisabled() { when(regCenter.isExisted("/state/disable/job/test_job")).thenReturn(true); assertTrue(disableJobService.isDisabled("test_job")); verify(regCenter).isExisted("/state/disable/job/test_job"); }
@Test public void assertIsEnabled() { when(regCenter.isExisted("/state/disable/job/test_job")).thenReturn(false); assertFalse(disableJobService.isDisabled("test_job")); verify(regCenter).isExisted("/state/disable/job/test_job"); }
|
### Question:
FailoverNode { static String getFailoverJobNodePath(final String jobName) { return String.format(FAILOVER_JOB, jobName); } }### Answer:
@Test public void assertGetFailoverJobNodePath() { Assert.assertThat(FailoverNode.getFailoverJobNodePath("test_job"), Is.is("/state/failover/test_job")); }
@Test public void assertGetFailoverJobNodePath() { assertThat(FailoverNode.getFailoverJobNodePath("test_job"), is("/state/failover/test_job")); }
|
### Question:
FailoverNode { static String getFailoverTaskNodePath(final String taskMetaInfo) { return String.format(FAILOVER_TASK, TaskContext.MetaInfo.from(taskMetaInfo).getJobName(), taskMetaInfo); } }### Answer:
@Test public void assertGetFailoverTaskNodePath() { String jobNodePath = TaskNode.builder().type(ExecutionType.FAILOVER).build().getTaskNodePath(); Assert.assertThat(FailoverNode.getFailoverTaskNodePath(jobNodePath), Is.is("/state/failover/test_job/" + jobNodePath)); }
|
### Question:
TaskExecutor implements Executor { @Override public void killTask(final ExecutorDriver executorDriver, final Protos.TaskID taskID) { executorDriver.sendStatusUpdate(Protos.TaskStatus.newBuilder().setTaskId(taskID).setState(Protos.TaskState.TASK_KILLED).build()); DaemonTaskScheduler.shutdown(taskID); } TaskExecutor(); @Override void registered(final ExecutorDriver executorDriver, final Protos.ExecutorInfo executorInfo, final Protos.FrameworkInfo frameworkInfo, final Protos.SlaveInfo slaveInfo); @Override void reregistered(final ExecutorDriver executorDriver, final Protos.SlaveInfo slaveInfo); @Override void disconnected(final ExecutorDriver executorDriver); @Override void launchTask(final ExecutorDriver executorDriver, final Protos.TaskInfo taskInfo); @Override void killTask(final ExecutorDriver executorDriver, final Protos.TaskID taskID); @Override void frameworkMessage(final ExecutorDriver executorDriver, final byte[] bytes); @Override void shutdown(final ExecutorDriver executorDriver); @Override void error(final ExecutorDriver executorDriver, final String message); }### Answer:
@Test public void assertKillTask() { TaskID taskID = Protos.TaskID.newBuilder().setValue("task_id").build(); taskExecutor.killTask(executorDriver, taskID); verify(executorDriver).sendStatusUpdate(Protos.TaskStatus.newBuilder().setTaskId(taskID).setState(Protos.TaskState.TASK_KILLED).build()); }
|
### Question:
FailoverService { public Collection<JobContext> getAllEligibleJobContexts() { if (!regCenter.isExisted(FailoverNode.ROOT)) { return Collections.emptyList(); } List<String> jobNames = regCenter.getChildrenKeys(FailoverNode.ROOT); Collection<JobContext> result = new ArrayList<>(jobNames.size()); Set<HashCode> assignedTasks = new HashSet<>(jobNames.size() * 10, 1); for (String each : jobNames) { List<String> taskIdList = regCenter.getChildrenKeys(FailoverNode.getFailoverJobNodePath(each)); if (taskIdList.isEmpty()) { regCenter.remove(FailoverNode.getFailoverJobNodePath(each)); continue; } Optional<CloudJobConfiguration> jobConfig = configService.load(each); if (!jobConfig.isPresent()) { regCenter.remove(FailoverNode.getFailoverJobNodePath(each)); continue; } List<Integer> assignedShardingItems = getAssignedShardingItems(each, taskIdList, assignedTasks); if (!assignedShardingItems.isEmpty() && jobConfig.isPresent()) { result.add(new JobContext(jobConfig.get(), assignedShardingItems, ExecutionType.FAILOVER)); } } return result; } FailoverService(final CoordinatorRegistryCenter regCenter); void add(final TaskContext taskContext); Collection<JobContext> getAllEligibleJobContexts(); void remove(final Collection<TaskContext.MetaInfo> metaInfoList); Optional<String> getTaskId(final TaskContext.MetaInfo metaInfo); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); }### Answer:
@Test public void assertGetAllEligibleJobContextsWithoutRootNode() { Mockito.when(regCenter.isExisted("/state/failover")).thenReturn(false); Assert.assertTrue(failoverService.getAllEligibleJobContexts().isEmpty()); Mockito.verify(regCenter).isExisted("/state/failover"); }
|
### Question:
FailoverService { public void remove(final Collection<TaskContext.MetaInfo> metaInfoList) { for (TaskContext.MetaInfo each : metaInfoList) { regCenter.remove(FailoverNode.getFailoverTaskNodePath(each.toString())); } } FailoverService(final CoordinatorRegistryCenter regCenter); void add(final TaskContext taskContext); Collection<JobContext> getAllEligibleJobContexts(); void remove(final Collection<TaskContext.MetaInfo> metaInfoList); Optional<String> getTaskId(final TaskContext.MetaInfo metaInfo); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); }### Answer:
@Test public void assertRemove() { String jobNodePath1 = TaskNode.builder().type(ExecutionType.FAILOVER).build().getTaskNodePath(); String jobNodePath2 = TaskNode.builder().shardingItem(1).type(ExecutionType.FAILOVER).build().getTaskNodePath(); failoverService.remove(Arrays.asList(TaskContext.MetaInfo.from(jobNodePath1), TaskContext.MetaInfo.from(jobNodePath2))); Mockito.verify(regCenter).remove("/state/failover/test_job/" + jobNodePath1); Mockito.verify(regCenter).remove("/state/failover/test_job/" + jobNodePath2); }
|
### Question:
ReadyNode { static String getReadyJobNodePath(final String jobName) { return String.format(READY_JOB, jobName); } }### Answer:
@Test public void assertGetReadyJobNodePath() { Assert.assertThat(ReadyNode.getReadyJobNodePath("test_job0000000001"), Is.is("/state/ready/test_job0000000001")); }
@Test public void assertGetReadyJobNodePath() { assertThat(ReadyNode.getReadyJobNodePath("test_job0000000001"), is("/state/ready/test_job0000000001")); }
|
### Question:
CloudJobFacade implements JobFacade { @Override public void checkJobExecutionEnvironment() throws JobExecutionEnvironmentException { } @Override JobRootConfiguration loadJobRootConfiguration(final boolean fromCache); @Override void checkJobExecutionEnvironment(); @Override void failoverIfNecessary(); @Override void registerJobBegin(final ShardingContexts shardingContexts); @Override void registerJobCompleted(final ShardingContexts shardingContexts); ShardingContexts getShardingContexts(); @Override boolean misfireIfRunning(final Collection<Integer> shardingItems); @Override void clearMisfire(final Collection<Integer> shardingItems); @Override boolean isExecuteMisfired(final Collection<Integer> shardingItems); @Override boolean isEligibleForJobRunning(); @Override boolean isNeedSharding(); @Override void beforeJobExecuted(final ShardingContexts shardingContexts); @Override void afterJobExecuted(final ShardingContexts shardingContexts); @Override void postJobExecutionEvent(final JobExecutionEvent jobExecutionEvent); @Override void postJobStatusTraceEvent(final String taskId, final JobStatusTraceEvent.State state, final String message); }### Answer:
@Test public void assertCheckJobExecutionEnvironment() throws JobExecutionEnvironmentException { jobFacade.checkJobExecutionEnvironment(); }
|
### Question:
ReadyService { public void setMisfireDisabled(final String jobName) { Optional<CloudJobConfiguration> cloudJobConfig = configService.load(jobName); if (cloudJobConfig.isPresent() && null != regCenter.getDirectly(ReadyNode.getReadyJobNodePath(jobName))) { regCenter.persist(ReadyNode.getReadyJobNodePath(jobName), "1"); } } ReadyService(final CoordinatorRegistryCenter regCenter); void addTransient(final String jobName); void addDaemon(final String jobName); void setMisfireDisabled(final String jobName); Collection<JobContext> getAllEligibleJobContexts(final Collection<JobContext> ineligibleJobContexts); void remove(final Collection<String> jobNames); Map<String, Integer> getAllReadyTasks(); }### Answer:
@Test public void assertSetMisfireDisabledWhenJobIsNotExisted() { Mockito.when(configService.load("test_job")).thenReturn(Optional.<CloudJobConfiguration>absent()); readyService.setMisfireDisabled("test_job"); Mockito.verify(regCenter, Mockito.times(0)).persist("/state/ready/test_job", "1"); }
@Test public void assertSetMisfireDisabledWhenReadyNodeNotExisted() { Mockito.when(configService.load("test_job")).thenReturn(Optional.of(CloudJobConfigurationBuilder.createCloudJobConfiguration("test_job"))); readyService.setMisfireDisabled("test_job"); Mockito.verify(regCenter, Mockito.times(0)).persist("/state/ready/test_job", "1"); }
@Test public void assertSetMisfireDisabledWhenReadyNodeExisted() { Mockito.when(configService.load("test_job")).thenReturn(Optional.of(CloudJobConfigurationBuilder.createCloudJobConfiguration("test_job"))); Mockito.when(regCenter.getDirectly("/state/ready/test_job")).thenReturn("100"); readyService.setMisfireDisabled("test_job"); Mockito.verify(regCenter).persist("/state/ready/test_job", "1"); }
|
### Question:
TaskExecutor implements Executor { @Override public void launchTask(final ExecutorDriver executorDriver, final Protos.TaskInfo taskInfo) { executorService.submit(new TaskThread(executorDriver, taskInfo)); } TaskExecutor(); @Override void registered(final ExecutorDriver executorDriver, final Protos.ExecutorInfo executorInfo, final Protos.FrameworkInfo frameworkInfo, final Protos.SlaveInfo slaveInfo); @Override void reregistered(final ExecutorDriver executorDriver, final Protos.SlaveInfo slaveInfo); @Override void disconnected(final ExecutorDriver executorDriver); @Override void launchTask(final ExecutorDriver executorDriver, final Protos.TaskInfo taskInfo); @Override void killTask(final ExecutorDriver executorDriver, final Protos.TaskID taskID); @Override void frameworkMessage(final ExecutorDriver executorDriver, final byte[] bytes); @Override void shutdown(final ExecutorDriver executorDriver); @Override void error(final ExecutorDriver executorDriver, final String message); }### Answer:
@Test public void assertLaunchTask() { taskExecutor.launchTask(executorDriver, TaskInfo.newBuilder().setName("test_job") .setTaskId(TaskID.newBuilder().setValue("fake_task_id")).setSlaveId(Protos.SlaveID.newBuilder().setValue("slave-S0")).build()); }
|
### Question:
CloudAppConfigurationNode { static String getRootNodePath(final String appName) { return String.format(APP_CONFIG, appName); } static final String ROOT; }### Answer:
@Test public void assertGetRootNodePath() { Assert.assertThat(CloudAppConfigurationNode.getRootNodePath("test_job_app"), Is.is("/config/app/test_job_app")); }
@Test public void assertGetRootNodePath() { assertThat(CloudAppConfigurationNode.getRootNodePath("test_job_app"), is("/config/app/test_job_app")); }
|
### Question:
CloudAppConfigurationService { public void add(final CloudAppConfiguration appConfig) { regCenter.persist(CloudAppConfigurationNode.getRootNodePath(appConfig.getAppName()), CloudAppConfigurationGsonFactory.toJson(appConfig)); } void add(final CloudAppConfiguration appConfig); void update(final CloudAppConfiguration appConfig); Optional<CloudAppConfiguration> load(final String appName); Collection<CloudAppConfiguration> loadAll(); void remove(final String appName); }### Answer:
@Test public void assertAdd() { CloudAppConfiguration appConfig = CloudAppConfigurationBuilder.createCloudAppConfiguration("test_app"); configService.add(appConfig); Mockito.verify(regCenter).persist("/config/app/test_app", CloudAppJsonConstants.getAppJson("test_app")); }
|
### Question:
CloudAppConfigurationService { public void update(final CloudAppConfiguration appConfig) { regCenter.update(CloudAppConfigurationNode.getRootNodePath(appConfig.getAppName()), CloudAppConfigurationGsonFactory.toJson(appConfig)); } void add(final CloudAppConfiguration appConfig); void update(final CloudAppConfiguration appConfig); Optional<CloudAppConfiguration> load(final String appName); Collection<CloudAppConfiguration> loadAll(); void remove(final String appName); }### Answer:
@Test public void assertUpdate() { CloudAppConfiguration appConfig = CloudAppConfigurationBuilder.createCloudAppConfiguration("test_app"); configService.update(appConfig); Mockito.verify(regCenter).update("/config/app/test_app", CloudAppJsonConstants.getAppJson("test_app")); }
|
### Question:
CloudAppConfigurationService { public Collection<CloudAppConfiguration> loadAll() { if (!regCenter.isExisted(CloudAppConfigurationNode.ROOT)) { return Collections.emptyList(); } List<String> appNames = regCenter.getChildrenKeys(CloudAppConfigurationNode.ROOT); Collection<CloudAppConfiguration> result = new ArrayList<>(appNames.size()); for (String each : appNames) { Optional<CloudAppConfiguration> config = load(each); if (config.isPresent()) { result.add(config.get()); } } return result; } void add(final CloudAppConfiguration appConfig); void update(final CloudAppConfiguration appConfig); Optional<CloudAppConfiguration> load(final String appName); Collection<CloudAppConfiguration> loadAll(); void remove(final String appName); }### Answer:
@Test public void assertLoadAllWithoutRootNode() { Mockito.when(regCenter.isExisted("/config/app")).thenReturn(false); Assert.assertTrue(configService.loadAll().isEmpty()); Mockito.verify(regCenter).isExisted("/config/app"); }
@Test public void assertLoadAllWithRootNode() { Mockito.when(regCenter.isExisted("/config/app")).thenReturn(true); Mockito.when(regCenter.getChildrenKeys(CloudAppConfigurationNode.ROOT)).thenReturn(Arrays.asList("test_app_1", "test_app_2")); Mockito.when(regCenter.get("/config/app/test_app_1")).thenReturn(CloudAppJsonConstants.getAppJson("test_app_1")); Collection<CloudAppConfiguration> actual = configService.loadAll(); Assert.assertThat(actual.size(), Is.is(1)); Assert.assertThat(actual.iterator().next().getAppName(), Is.is("test_app_1")); Mockito.verify(regCenter).isExisted("/config/app"); Mockito.verify(regCenter).getChildrenKeys("/config/app"); Mockito.verify(regCenter).get("/config/app/test_app_1"); Mockito.verify(regCenter).get("/config/app/test_app_2"); }
|
### Question:
CloudAppConfigurationService { public Optional<CloudAppConfiguration> load(final String appName) { return Optional.fromNullable(CloudAppConfigurationGsonFactory.fromJson(regCenter.get(CloudAppConfigurationNode.getRootNodePath(appName)))); } void add(final CloudAppConfiguration appConfig); void update(final CloudAppConfiguration appConfig); Optional<CloudAppConfiguration> load(final String appName); Collection<CloudAppConfiguration> loadAll(); void remove(final String appName); }### Answer:
@Test public void assertLoadWithoutConfig() { Optional<CloudAppConfiguration> actual = configService.load("test_app"); Assert.assertFalse(actual.isPresent()); }
@Test public void assertLoadWithConfig() { Mockito.when(regCenter.get("/config/app/test_app")).thenReturn(CloudAppJsonConstants.getAppJson("test_app")); Optional<CloudAppConfiguration> actual = configService.load("test_app"); Assert.assertTrue(actual.isPresent()); Assert.assertThat(actual.get().getAppName(), Is.is("test_app")); }
|
### Question:
TaskExecutor implements Executor { @Override public void reregistered(final ExecutorDriver executorDriver, final Protos.SlaveInfo slaveInfo) { } TaskExecutor(); @Override void registered(final ExecutorDriver executorDriver, final Protos.ExecutorInfo executorInfo, final Protos.FrameworkInfo frameworkInfo, final Protos.SlaveInfo slaveInfo); @Override void reregistered(final ExecutorDriver executorDriver, final Protos.SlaveInfo slaveInfo); @Override void disconnected(final ExecutorDriver executorDriver); @Override void launchTask(final ExecutorDriver executorDriver, final Protos.TaskInfo taskInfo); @Override void killTask(final ExecutorDriver executorDriver, final Protos.TaskID taskID); @Override void frameworkMessage(final ExecutorDriver executorDriver, final byte[] bytes); @Override void shutdown(final ExecutorDriver executorDriver); @Override void error(final ExecutorDriver executorDriver, final String message); }### Answer:
@Test public void assertReregistered() { taskExecutor.reregistered(executorDriver, slaveInfo); }
|
### Question:
CloudAppConfigurationService { public void remove(final String appName) { regCenter.remove(CloudAppConfigurationNode.getRootNodePath(appName)); } void add(final CloudAppConfiguration appConfig); void update(final CloudAppConfiguration appConfig); Optional<CloudAppConfiguration> load(final String appName); Collection<CloudAppConfiguration> loadAll(); void remove(final String appName); }### Answer:
@Test public void assertRemove() { configService.remove("test_app"); Mockito.verify(regCenter).remove("/config/app/test_app"); }
|
### Question:
TaskExecutor implements Executor { @Override public void disconnected(final ExecutorDriver executorDriver) { } TaskExecutor(); @Override void registered(final ExecutorDriver executorDriver, final Protos.ExecutorInfo executorInfo, final Protos.FrameworkInfo frameworkInfo, final Protos.SlaveInfo slaveInfo); @Override void reregistered(final ExecutorDriver executorDriver, final Protos.SlaveInfo slaveInfo); @Override void disconnected(final ExecutorDriver executorDriver); @Override void launchTask(final ExecutorDriver executorDriver, final Protos.TaskInfo taskInfo); @Override void killTask(final ExecutorDriver executorDriver, final Protos.TaskID taskID); @Override void frameworkMessage(final ExecutorDriver executorDriver, final byte[] bytes); @Override void shutdown(final ExecutorDriver executorDriver); @Override void error(final ExecutorDriver executorDriver, final String message); }### Answer:
@Test public void assertDisconnected() { taskExecutor.disconnected(executorDriver); }
|
### Question:
CloudJobConfigurationService { public void add(final CloudJobConfiguration jobConfig) { regCenter.persist(CloudJobConfigurationNode.getRootNodePath(jobConfig.getJobName()), CloudJobConfigurationGsonFactory.toJson(jobConfig)); } void add(final CloudJobConfiguration jobConfig); void update(final CloudJobConfiguration jobConfig); Collection<CloudJobConfiguration> loadAll(); Optional<CloudJobConfiguration> load(final String jobName); void remove(final String jobName); }### Answer:
@Test public void assertAdd() { CloudJobConfiguration jobConfig = CloudJobConfigurationBuilder.createCloudJobConfiguration("test_job"); configService.add(jobConfig); Mockito.verify(regCenter).persist("/config/job/test_job", CloudJsonConstants.getJobJson()); }
@Test public void assertAddSpringJob() { CloudJobConfiguration jobConfig = CloudJobConfigurationBuilder.createCloudSpringJobConfiguration("test_spring_job"); configService.add(jobConfig); Mockito.verify(regCenter).persist("/config/job/test_spring_job", CloudJsonConstants.getSpringJobJson()); }
|
### Question:
CloudJobConfigurationService { public void update(final CloudJobConfiguration jobConfig) { regCenter.update(CloudJobConfigurationNode.getRootNodePath(jobConfig.getJobName()), CloudJobConfigurationGsonFactory.toJson(jobConfig)); } void add(final CloudJobConfiguration jobConfig); void update(final CloudJobConfiguration jobConfig); Collection<CloudJobConfiguration> loadAll(); Optional<CloudJobConfiguration> load(final String jobName); void remove(final String jobName); }### Answer:
@Test public void assertUpdate() { CloudJobConfiguration jobConfig = CloudJobConfigurationBuilder.createCloudJobConfiguration("test_job"); configService.update(jobConfig); Mockito.verify(regCenter).update("/config/job/test_job", CloudJsonConstants.getJobJson()); }
|
### Question:
CloudJobConfigurationService { public Collection<CloudJobConfiguration> loadAll() { if (!regCenter.isExisted(CloudJobConfigurationNode.ROOT)) { return Collections.emptyList(); } List<String> jobNames = regCenter.getChildrenKeys(CloudJobConfigurationNode.ROOT); Collection<CloudJobConfiguration> result = new ArrayList<>(jobNames.size()); for (String each : jobNames) { Optional<CloudJobConfiguration> config = load(each); if (config.isPresent()) { result.add(config.get()); } } return result; } void add(final CloudJobConfiguration jobConfig); void update(final CloudJobConfiguration jobConfig); Collection<CloudJobConfiguration> loadAll(); Optional<CloudJobConfiguration> load(final String jobName); void remove(final String jobName); }### Answer:
@Test public void assertLoadAllWithoutRootNode() { Mockito.when(regCenter.isExisted("/config/job")).thenReturn(false); Assert.assertTrue(configService.loadAll().isEmpty()); Mockito.verify(regCenter).isExisted("/config/job"); }
@Test public void assertLoadAllWithRootNode() { Mockito.when(regCenter.isExisted("/config/job")).thenReturn(true); Mockito.when(regCenter.getChildrenKeys(CloudJobConfigurationNode.ROOT)).thenReturn(Arrays.asList("test_job_1", "test_job_2")); Mockito.when(regCenter.get("/config/job/test_job_1")).thenReturn(CloudJsonConstants.getJobJson("test_job_1")); Collection<CloudJobConfiguration> actual = configService.loadAll(); Assert.assertThat(actual.size(), Is.is(1)); Assert.assertThat(actual.iterator().next().getJobName(), Is.is("test_job_1")); Mockito.verify(regCenter).isExisted("/config/job"); Mockito.verify(regCenter).getChildrenKeys("/config/job"); Mockito.verify(regCenter).get("/config/job/test_job_1"); Mockito.verify(regCenter).get("/config/job/test_job_2"); }
|
### Question:
CloudJobConfigurationService { public Optional<CloudJobConfiguration> load(final String jobName) { return Optional.fromNullable(CloudJobConfigurationGsonFactory.fromJson(regCenter.get(CloudJobConfigurationNode.getRootNodePath(jobName)))); } void add(final CloudJobConfiguration jobConfig); void update(final CloudJobConfiguration jobConfig); Collection<CloudJobConfiguration> loadAll(); Optional<CloudJobConfiguration> load(final String jobName); void remove(final String jobName); }### Answer:
@Test public void assertLoadWithoutConfig() { Optional<CloudJobConfiguration> actual = configService.load("test_job"); Assert.assertFalse(actual.isPresent()); }
@Test public void assertLoadWithConfig() { Mockito.when(regCenter.get("/config/job/test_job")).thenReturn(CloudJsonConstants.getJobJson()); Optional<CloudJobConfiguration> actual = configService.load("test_job"); Assert.assertTrue(actual.isPresent()); Assert.assertThat(actual.get().getJobName(), Is.is("test_job")); }
@Test public void assertLoadWithSpringConfig() { Mockito.when(regCenter.get("/config/job/test_spring_job")).thenReturn(CloudJsonConstants.getSpringJobJson()); Optional<CloudJobConfiguration> actual = configService.load("test_spring_job"); Assert.assertTrue(actual.isPresent()); Assert.assertThat(actual.get().getBeanName(), Is.is("springSimpleJob")); Assert.assertThat(actual.get().getApplicationContext(), Is.is("applicationContext.xml")); }
|
### Question:
CloudJobConfigurationService { public void remove(final String jobName) { regCenter.remove(CloudJobConfigurationNode.getRootNodePath(jobName)); } void add(final CloudJobConfiguration jobConfig); void update(final CloudJobConfiguration jobConfig); Collection<CloudJobConfiguration> loadAll(); Optional<CloudJobConfiguration> load(final String jobName); void remove(final String jobName); }### Answer:
@Test public void assertRemove() { configService.remove("test_job"); Mockito.verify(regCenter).remove("/config/job/test_job"); }
|
### Question:
CloudJobConfigurationNode { static String getRootNodePath(final String jobName) { return String.format(JOB_CONFIG, jobName); } static final String ROOT; }### Answer:
@Test public void assertGetRootNodePath() { Assert.assertThat(CloudJobConfigurationNode.getRootNodePath("test_job"), Is.is("/config/job/test_job")); }
@Test public void assertGetRootNodePath() { assertThat(CloudJobConfigurationNode.getRootNodePath("test_job"), is("/config/job/test_job")); }
|
### Question:
TaskExecutor implements Executor { @Override public void frameworkMessage(final ExecutorDriver executorDriver, final byte[] bytes) { if (null != bytes && "STOP".equals(new String(bytes))) { log.error("call frameworkMessage executor stopped."); executorDriver.stop(); } } TaskExecutor(); @Override void registered(final ExecutorDriver executorDriver, final Protos.ExecutorInfo executorInfo, final Protos.FrameworkInfo frameworkInfo, final Protos.SlaveInfo slaveInfo); @Override void reregistered(final ExecutorDriver executorDriver, final Protos.SlaveInfo slaveInfo); @Override void disconnected(final ExecutorDriver executorDriver); @Override void launchTask(final ExecutorDriver executorDriver, final Protos.TaskInfo taskInfo); @Override void killTask(final ExecutorDriver executorDriver, final Protos.TaskID taskID); @Override void frameworkMessage(final ExecutorDriver executorDriver, final byte[] bytes); @Override void shutdown(final ExecutorDriver executorDriver); @Override void error(final ExecutorDriver executorDriver, final String message); }### Answer:
@Test public void assertFrameworkMessage() { taskExecutor.frameworkMessage(executorDriver, null); }
|
### Question:
TransientProducerScheduler { synchronized void register(final CloudJobConfiguration jobConfig) { String cron = jobConfig.getTypeConfig().getCoreConfig().getCron(); JobKey jobKey = buildJobKey(cron); repository.put(jobKey, jobConfig.getJobName()); try { if (!scheduler.checkExists(jobKey)) { scheduler.scheduleJob(buildJobDetail(jobKey), buildTrigger(jobKey.getName())); } } catch (final SchedulerException ex) { throw new JobSystemException(ex); } } TransientProducerScheduler(final ReadyService readyService); }### Answer:
@Test public void assertRegister() throws SchedulerException { when(scheduler.checkExists(jobDetail.getKey())).thenReturn(false); transientProducerScheduler.register(jobConfig); verify(scheduler).checkExists(jobDetail.getKey()); verify(scheduler).scheduleJob(jobDetail, trigger); }
|
### Question:
TransientProducerScheduler { synchronized void deregister(final CloudJobConfiguration jobConfig) { repository.remove(jobConfig.getJobName()); String cron = jobConfig.getTypeConfig().getCoreConfig().getCron(); if (!repository.containsKey(buildJobKey(cron))) { try { scheduler.unscheduleJob(TriggerKey.triggerKey(cron)); } catch (final SchedulerException ex) { throw new JobSystemException(ex); } } } TransientProducerScheduler(final ReadyService readyService); }### Answer:
@Test public void assertDeregister() throws SchedulerException { transientProducerScheduler.deregister(jobConfig); verify(scheduler).unscheduleJob(TriggerKey.triggerKey(jobConfig.getTypeConfig().getCoreConfig().getCron())); }
|
### Question:
TaskExecutor implements Executor { @Override public void shutdown(final ExecutorDriver executorDriver) { } TaskExecutor(); @Override void registered(final ExecutorDriver executorDriver, final Protos.ExecutorInfo executorInfo, final Protos.FrameworkInfo frameworkInfo, final Protos.SlaveInfo slaveInfo); @Override void reregistered(final ExecutorDriver executorDriver, final Protos.SlaveInfo slaveInfo); @Override void disconnected(final ExecutorDriver executorDriver); @Override void launchTask(final ExecutorDriver executorDriver, final Protos.TaskInfo taskInfo); @Override void killTask(final ExecutorDriver executorDriver, final Protos.TaskID taskID); @Override void frameworkMessage(final ExecutorDriver executorDriver, final byte[] bytes); @Override void shutdown(final ExecutorDriver executorDriver); @Override void error(final ExecutorDriver executorDriver, final String message); }### Answer:
@Test public void assertShutdown() { taskExecutor.shutdown(executorDriver); }
|
### Question:
ProducerManager { public void shutdown() { log.info("Stop producer manager"); transientProducerScheduler.shutdown(); } ProducerManager(final SchedulerDriver schedulerDriver, final CoordinatorRegistryCenter regCenter); void startup(); void register(final CloudJobConfiguration jobConfig); void update(final CloudJobConfiguration jobConfig); void deregister(final String jobName); void schedule(final CloudJobConfiguration jobConfig); void unschedule(final String jobName); void reschedule(final String jobName); void sendFrameworkMessage(final ExecutorID executorId, final SlaveID slaveId, final byte[] data); void shutdown(); }### Answer:
@Test public void assertShutdown() { producerManager.shutdown(); verify(transientProducerScheduler).shutdown(); }
|
### Question:
FacadeService { public void start() { log.info("Elastic Job: Start facade service"); runningService.start(); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertStart() { facadeService.start(); Mockito.verify(runningService).start(); }
|
### Question:
FacadeService { public void addRunning(final TaskContext taskContext) { runningService.add(taskContext); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertAddRunning() { TaskContext taskContext = TaskContext.from(TaskNode.builder().build().getTaskNodeValue()); facadeService.addRunning(taskContext); Mockito.verify(runningService).add(taskContext); }
|
### Question:
FacadeService { public void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle) { runningService.updateIdle(taskContext, isIdle); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertUpdateDaemonStatus() { TaskContext taskContext = TaskContext.from(TaskNode.builder().build().getTaskNodeValue()); facadeService.updateDaemonStatus(taskContext, true); Mockito.verify(runningService).updateIdle(taskContext, true); }
|
### Question:
FacadeService { public void removeRunning(final TaskContext taskContext) { runningService.remove(taskContext); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertRemoveRunning() { String taskNodeValue = TaskNode.builder().build().getTaskNodeValue(); TaskContext taskContext = TaskContext.from(taskNodeValue); facadeService.removeRunning(taskContext); Mockito.verify(runningService).remove(taskContext); }
|
### Question:
FacadeService { public Optional<CloudJobConfiguration> load(final String jobName) { return jobConfigService.load(jobName); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertLoadJobConfig() { Optional<CloudJobConfiguration> jobConfigOptional = Optional.of(CloudJobConfigurationBuilder.createCloudJobConfiguration("test_job")); Mockito.when(jobConfigService.load("test_job")).thenReturn(jobConfigOptional); Assert.assertThat(facadeService.load("test_job"), Is.is(jobConfigOptional)); }
@Test public void assertLoadJobConfigWhenAbsent() { Mockito.when(jobConfigService.load("test_job")).thenReturn(Optional.<CloudJobConfiguration>absent()); Assert.assertThat(facadeService.load("test_job"), Is.is(Optional.<CloudJobConfiguration>absent())); }
|
### Question:
TaskExecutor implements Executor { @Override public void error(final ExecutorDriver executorDriver, final String message) { log.error("call executor error, message is: {}", message); } TaskExecutor(); @Override void registered(final ExecutorDriver executorDriver, final Protos.ExecutorInfo executorInfo, final Protos.FrameworkInfo frameworkInfo, final Protos.SlaveInfo slaveInfo); @Override void reregistered(final ExecutorDriver executorDriver, final Protos.SlaveInfo slaveInfo); @Override void disconnected(final ExecutorDriver executorDriver); @Override void launchTask(final ExecutorDriver executorDriver, final Protos.TaskInfo taskInfo); @Override void killTask(final ExecutorDriver executorDriver, final Protos.TaskID taskID); @Override void frameworkMessage(final ExecutorDriver executorDriver, final byte[] bytes); @Override void shutdown(final ExecutorDriver executorDriver); @Override void error(final ExecutorDriver executorDriver, final String message); }### Answer:
@Test public void assertError() { taskExecutor.error(executorDriver, ""); }
|
### Question:
FacadeService { public void addMapping(final String taskId, final String hostname) { runningService.addMapping(taskId, hostname); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertAddMapping() { facadeService.addMapping("taskId", "localhost"); Mockito.verify(runningService).addMapping("taskId", "localhost"); }
|
### Question:
FacadeService { public String popMapping(final String taskId) { return runningService.popMapping(taskId); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertPopMapping() { facadeService.popMapping("taskId"); Mockito.verify(runningService).popMapping("taskId"); }
|
### Question:
FacadeService { public void stop() { log.info("Elastic Job: Stop facade service"); runningService.clear(); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertStop() { facadeService.stop(); Mockito.verify(runningService).clear(); }
|
### Question:
FacadeService { public void enableJob(final String jobName) { disableJobService.remove(jobName); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertEnableJob() { facadeService.enableJob("test_job"); Mockito.verify(disableJobService).remove("test_job"); }
|
### Question:
FacadeService { public void disableJob(final String jobName) { disableJobService.add(jobName); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertDisableJob() { facadeService.disableJob("test_job"); Mockito.verify(disableJobService).add("test_job"); }
|
### Question:
FacadeService { public Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo() throws JSONException { return mesosStateService.executors(); } FacadeService(final CoordinatorRegistryCenter regCenter); void start(); Collection<JobContext> getEligibleJobContext(); void removeLaunchTasksFromQueue(final List<TaskContext> taskContexts); void addRunning(final TaskContext taskContext); void updateDaemonStatus(final TaskContext taskContext, final boolean isIdle); void removeRunning(final TaskContext taskContext); void recordFailoverTask(final TaskContext taskContext); void addTransient(final String jobName); Optional<CloudJobConfiguration> load(final String jobName); Optional<CloudAppConfiguration> loadAppConfig(final String appName); Optional<String> getFailoverTaskId(final TaskContext.MetaInfo metaInfo); void addDaemonJobToReadyQueue(final String jobName); boolean isRunning(final TaskContext taskContext); void addMapping(final String taskId, final String hostname); String popMapping(final String taskId); Map<String, Integer> getAllReadyTasks(); Map<String, Set<TaskContext>> getAllRunningTasks(); Map<String, Collection<FailoverTaskInfo>> getAllFailoverTasks(); boolean isJobDisabled(final String jobName); void enableJob(final String jobName); void disableJob(final String jobName); Collection<MesosStateService.ExecutorStateInfo> loadExecutorInfo(); void stop(); }### Answer:
@Test public void assertLoadExecutor() throws Exception { facadeService.loadExecutorInfo(); Mockito.verify(mesosStateService).executors(); }
|
### Question:
ReconcileService extends AbstractScheduledService { @Override protected void runOneIteration() throws Exception { lock.lock(); try { explicitReconcile(); implicitReconcile(); } finally { lock.unlock(); } } void explicitReconcile(); void implicitReconcile(); }### Answer:
@Test public void assertRunOneIteration() throws Exception { reconcileService.runOneIteration(); verify(schedulerDriver).reconcileTasks(Collections.<Protos.TaskStatus>emptyList()); }
|
### Question:
ReconcileService extends AbstractScheduledService { public void implicitReconcile() { lock.lock(); try { schedulerDriver.reconcileTasks(Collections.<Protos.TaskStatus>emptyList()); } finally { lock.unlock(); } } void explicitReconcile(); void implicitReconcile(); }### Answer:
@Test public void assertImplicitReconcile() { reconcileService.implicitReconcile(); verify(schedulerDriver).reconcileTasks(Collections.<Protos.TaskStatus>emptyList()); }
|
### Question:
ReconcileService extends AbstractScheduledService { public void explicitReconcile() { lock.lock(); try { Set<TaskContext> runningTask = new HashSet<>(); for (Set<TaskContext> each : facadeService.getAllRunningTasks().values()) { runningTask.addAll(each); } if (runningTask.isEmpty()) { return; } log.info("Requesting {} tasks reconciliation with the Mesos master", runningTask.size()); schedulerDriver.reconcileTasks(Collections2.transform(runningTask, new Function<TaskContext, Protos.TaskStatus>() { @Override public Protos.TaskStatus apply(final TaskContext input) { return Protos.TaskStatus.newBuilder() .setTaskId(Protos.TaskID.newBuilder().setValue(input.getId()).build()) .setSlaveId(Protos.SlaveID.newBuilder().setValue(input.getSlaveId()).build()) .setState(Protos.TaskState.TASK_RUNNING).build(); } })); } finally { lock.unlock(); } } void explicitReconcile(); void implicitReconcile(); }### Answer:
@Test public void assertExplicitReconcile() { Map<String, Set<TaskContext>> runningTaskMap = new HashMap<>(); runningTaskMap.put("transient_test_job", Sets.newHashSet( TaskContext.from("transient_test_job@-@0@-@READY@-@SLAVE-S0@-@UUID"), TaskContext.from("transient_test_job@-@1@-@READY@-@SLAVE-S0@-@UUID"))); when(facadeService.getAllRunningTasks()).thenReturn(runningTaskMap); reconcileService.explicitReconcile(); verify(schedulerDriver).reconcileTasks(taskStatusCaptor.capture()); assertThat(taskStatusCaptor.getValue().size(), is(2)); for (Protos.TaskStatus each : taskStatusCaptor.getValue()) { assertThat(each.getSlaveId().getValue(), is("SLAVE-S0")); assertThat(each.getState(), is(Protos.TaskState.TASK_RUNNING)); } }
|
### Question:
SchedulerEngine implements Scheduler { @Override public void registered(final SchedulerDriver schedulerDriver, final Protos.FrameworkID frameworkID, final Protos.MasterInfo masterInfo) { log.info("call registered"); frameworkIDService.save(frameworkID.getValue()); taskScheduler.expireAllLeases(); MesosStateService.register(masterInfo.getHostname(), masterInfo.getPort()); } @Override void registered(final SchedulerDriver schedulerDriver, final Protos.FrameworkID frameworkID, final Protos.MasterInfo masterInfo); @Override void reregistered(final SchedulerDriver schedulerDriver, final Protos.MasterInfo masterInfo); @Override void resourceOffers(final SchedulerDriver schedulerDriver, final List<Protos.Offer> offers); @Override void offerRescinded(final SchedulerDriver schedulerDriver, final Protos.OfferID offerID); @Override void statusUpdate(final SchedulerDriver schedulerDriver, final Protos.TaskStatus taskStatus); @Override void frameworkMessage(final SchedulerDriver schedulerDriver, final Protos.ExecutorID executorID, final Protos.SlaveID slaveID, final byte[] bytes); @Override void disconnected(final SchedulerDriver schedulerDriver); @Override void slaveLost(final SchedulerDriver schedulerDriver, final Protos.SlaveID slaveID); @Override void executorLost(final SchedulerDriver schedulerDriver, final Protos.ExecutorID executorID, final Protos.SlaveID slaveID, final int i); @Override void error(final SchedulerDriver schedulerDriver, final String message); }### Answer:
@Test public void assertRegistered() { schedulerEngine.registered(null, Protos.FrameworkID.newBuilder().setValue("1").build(), Protos.MasterInfo.getDefaultInstance()); Mockito.verify(taskScheduler).expireAllLeases(); Mockito.verify(frameworkIDService).save("1"); }
@Test public void assertRegistered() { schedulerEngine.registered(null, Protos.FrameworkID.newBuilder().setValue("1").build(), Protos.MasterInfo.getDefaultInstance()); verify(taskScheduler).expireAllLeases(); verify(frameworkIDService).save("1"); }
|
### Question:
SchedulerEngine implements Scheduler { @Override public void reregistered(final SchedulerDriver schedulerDriver, final Protos.MasterInfo masterInfo) { log.info("call reregistered"); taskScheduler.expireAllLeases(); MesosStateService.register(masterInfo.getHostname(), masterInfo.getPort()); } @Override void registered(final SchedulerDriver schedulerDriver, final Protos.FrameworkID frameworkID, final Protos.MasterInfo masterInfo); @Override void reregistered(final SchedulerDriver schedulerDriver, final Protos.MasterInfo masterInfo); @Override void resourceOffers(final SchedulerDriver schedulerDriver, final List<Protos.Offer> offers); @Override void offerRescinded(final SchedulerDriver schedulerDriver, final Protos.OfferID offerID); @Override void statusUpdate(final SchedulerDriver schedulerDriver, final Protos.TaskStatus taskStatus); @Override void frameworkMessage(final SchedulerDriver schedulerDriver, final Protos.ExecutorID executorID, final Protos.SlaveID slaveID, final byte[] bytes); @Override void disconnected(final SchedulerDriver schedulerDriver); @Override void slaveLost(final SchedulerDriver schedulerDriver, final Protos.SlaveID slaveID); @Override void executorLost(final SchedulerDriver schedulerDriver, final Protos.ExecutorID executorID, final Protos.SlaveID slaveID, final int i); @Override void error(final SchedulerDriver schedulerDriver, final String message); }### Answer:
@Test public void assertReregistered() { schedulerEngine.reregistered(null, Protos.MasterInfo.getDefaultInstance()); Mockito.verify(taskScheduler).expireAllLeases(); }
@Test public void assertReregistered() { schedulerEngine.reregistered(null, Protos.MasterInfo.getDefaultInstance()); verify(taskScheduler).expireAllLeases(); }
|
### Question:
SchedulerEngine implements Scheduler { @Override public void offerRescinded(final SchedulerDriver schedulerDriver, final Protos.OfferID offerID) { log.trace("call offerRescinded: {}", offerID); taskScheduler.expireLease(offerID.getValue()); } @Override void registered(final SchedulerDriver schedulerDriver, final Protos.FrameworkID frameworkID, final Protos.MasterInfo masterInfo); @Override void reregistered(final SchedulerDriver schedulerDriver, final Protos.MasterInfo masterInfo); @Override void resourceOffers(final SchedulerDriver schedulerDriver, final List<Protos.Offer> offers); @Override void offerRescinded(final SchedulerDriver schedulerDriver, final Protos.OfferID offerID); @Override void statusUpdate(final SchedulerDriver schedulerDriver, final Protos.TaskStatus taskStatus); @Override void frameworkMessage(final SchedulerDriver schedulerDriver, final Protos.ExecutorID executorID, final Protos.SlaveID slaveID, final byte[] bytes); @Override void disconnected(final SchedulerDriver schedulerDriver); @Override void slaveLost(final SchedulerDriver schedulerDriver, final Protos.SlaveID slaveID); @Override void executorLost(final SchedulerDriver schedulerDriver, final Protos.ExecutorID executorID, final Protos.SlaveID slaveID, final int i); @Override void error(final SchedulerDriver schedulerDriver, final String message); }### Answer:
@Test public void assertOfferRescinded() { schedulerEngine.offerRescinded(null, Protos.OfferID.newBuilder().setValue("myOffer").build()); Mockito.verify(taskScheduler).expireLease("myOffer"); }
@Test public void assertOfferRescinded() { schedulerEngine.offerRescinded(null, Protos.OfferID.newBuilder().setValue("myOffer").build()); verify(taskScheduler).expireLease("myOffer"); }
|
### Question:
SchedulerEngine implements Scheduler { @Override public void slaveLost(final SchedulerDriver schedulerDriver, final Protos.SlaveID slaveID) { log.warn("call slaveLost slaveID is: {}", slaveID); taskScheduler.expireAllLeasesByVMId(slaveID.getValue()); } @Override void registered(final SchedulerDriver schedulerDriver, final Protos.FrameworkID frameworkID, final Protos.MasterInfo masterInfo); @Override void reregistered(final SchedulerDriver schedulerDriver, final Protos.MasterInfo masterInfo); @Override void resourceOffers(final SchedulerDriver schedulerDriver, final List<Protos.Offer> offers); @Override void offerRescinded(final SchedulerDriver schedulerDriver, final Protos.OfferID offerID); @Override void statusUpdate(final SchedulerDriver schedulerDriver, final Protos.TaskStatus taskStatus); @Override void frameworkMessage(final SchedulerDriver schedulerDriver, final Protos.ExecutorID executorID, final Protos.SlaveID slaveID, final byte[] bytes); @Override void disconnected(final SchedulerDriver schedulerDriver); @Override void slaveLost(final SchedulerDriver schedulerDriver, final Protos.SlaveID slaveID); @Override void executorLost(final SchedulerDriver schedulerDriver, final Protos.ExecutorID executorID, final Protos.SlaveID slaveID, final int i); @Override void error(final SchedulerDriver schedulerDriver, final String message); }### Answer:
@Test public void assertSlaveLost() { schedulerEngine.slaveLost(null, Protos.SlaveID.newBuilder().setValue("slave-S0").build()); Mockito.verify(taskScheduler).expireAllLeasesByVMId("slave-S0"); }
@Test public void assertSlaveLost() { schedulerEngine.slaveLost(null, Protos.SlaveID.newBuilder().setValue("slave-S0").build()); verify(taskScheduler).expireAllLeasesByVMId("slave-S0"); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public String getId() { return taskContext.getId(); } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetId() { Assert.assertThat(jobTaskRequest.getId(), StringStartsWith.startsWith("test_job@-@0@-@READY@-@unassigned-slave")); }
@Test public void assertGetId() { assertThat(jobTaskRequest.getId(), StringStartsWith.startsWith("test_job@-@0@-@READY@-@unassigned-slave")); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public String taskGroupName() { return ""; } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertTaskGroupName() { Assert.assertThat(jobTaskRequest.taskGroupName(), Is.is("")); }
@Test public void assertTaskGroupName() { assertThat(jobTaskRequest.taskGroupName(), is("")); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public double getCPUs() { return jobConfig.getCpuCount(); } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetCPUs() { Assert.assertThat(jobTaskRequest.getCPUs(), Is.is(1.0d)); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public double getMemory() { return jobConfig.getMemoryMB(); } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetMemory() { Assert.assertThat(jobTaskRequest.getMemory(), Is.is(128.0d)); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public double getNetworkMbps() { return 0; } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetNetworkMbps() { Assert.assertThat(jobTaskRequest.getNetworkMbps(), Is.is(0d)); }
@Test public void assertGetNetworkMbps() { assertThat(jobTaskRequest.getNetworkMbps(), is(0d)); }
|
### Question:
CloudJobFacade implements JobFacade { @Override public void failoverIfNecessary() { } @Override JobRootConfiguration loadJobRootConfiguration(final boolean fromCache); @Override void checkJobExecutionEnvironment(); @Override void failoverIfNecessary(); @Override void registerJobBegin(final ShardingContexts shardingContexts); @Override void registerJobCompleted(final ShardingContexts shardingContexts); ShardingContexts getShardingContexts(); @Override boolean misfireIfRunning(final Collection<Integer> shardingItems); @Override void clearMisfire(final Collection<Integer> shardingItems); @Override boolean isExecuteMisfired(final Collection<Integer> shardingItems); @Override boolean isEligibleForJobRunning(); @Override boolean isNeedSharding(); @Override void beforeJobExecuted(final ShardingContexts shardingContexts); @Override void afterJobExecuted(final ShardingContexts shardingContexts); @Override void postJobExecutionEvent(final JobExecutionEvent jobExecutionEvent); @Override void postJobStatusTraceEvent(final String taskId, final JobStatusTraceEvent.State state, final String message); }### Answer:
@Test public void assertFailoverIfNecessary() { jobFacade.failoverIfNecessary(); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public double getDisk() { return 10d; } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetDisk() { Assert.assertThat(jobTaskRequest.getDisk(), Is.is(10d)); }
@Test public void assertGetDisk() { assertThat(jobTaskRequest.getDisk(), is(10d)); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public int getPorts() { return 1; } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetPorts() { Assert.assertThat(jobTaskRequest.getPorts(), Is.is(1)); }
@Test public void assertGetPorts() { assertThat(jobTaskRequest.getPorts(), is(1)); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public Map<String, Double> getScalarRequests() { return null; } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetScalarRequests() { Assert.assertNull(jobTaskRequest.getScalarRequests()); }
@Test public void assertGetScalarRequests() { assertNull(jobTaskRequest.getScalarRequests()); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public List<? extends ConstraintEvaluator> getHardConstraints() { return Collections.singletonList(AppConstraintEvaluator.getInstance()); } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetHardConstraints() { AppConstraintEvaluator.init(null); Assert.assertThat(jobTaskRequest.getHardConstraints().size(), Is.is(1)); }
@Test public void assertGetHardConstraints() { AppConstraintEvaluator.init(null); assertThat(jobTaskRequest.getHardConstraints().size(), is(1)); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public List<? extends VMTaskFitnessCalculator> getSoftConstraints() { return null; } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetSoftConstraints() { Assert.assertNull(jobTaskRequest.getSoftConstraints()); }
@Test public void assertGetSoftConstraints() { assertNull(jobTaskRequest.getSoftConstraints()); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public AssignedResources getAssignedResources() { return null; } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetAssignedResources() { Assert.assertNull(jobTaskRequest.getAssignedResources()); }
@Test public void assertGetAssignedResources() { assertNull(jobTaskRequest.getAssignedResources()); }
|
### Question:
JobTaskRequest implements TaskRequest { @Override public Map<String, NamedResourceSetRequest> getCustomNamedResources() { return Collections.emptyMap(); } @Override String getId(); @Override String taskGroupName(); @Override double getCPUs(); @Override double getMemory(); @Override double getNetworkMbps(); @Override double getDisk(); @Override int getPorts(); @Override Map<String, Double> getScalarRequests(); @Override List<? extends ConstraintEvaluator> getHardConstraints(); @Override List<? extends VMTaskFitnessCalculator> getSoftConstraints(); @Override void setAssignedResources(final AssignedResources assignedResources); @Override AssignedResources getAssignedResources(); @Override Map<String, NamedResourceSetRequest> getCustomNamedResources(); }### Answer:
@Test public void assertGetCustomNamedResources() { Assert.assertThat(jobTaskRequest.getCustomNamedResources(), Is.is(Collections.<String, TaskRequest.NamedResourceSetRequest>emptyMap())); }
@Test public void assertGetCustomNamedResources() { assertThat(jobTaskRequest.getCustomNamedResources(), is(Collections.<String, TaskRequest.NamedResourceSetRequest>emptyMap())); }
|
### Question:
TaskInfoData { public byte[] serialize() { Map<String, Object> result = new LinkedHashMap<>(2, 1); result.put("shardingContext", shardingContexts); result.put("jobConfigContext", buildJobConfigurationContext()); return SerializationUtils.serialize((LinkedHashMap) result); } byte[] serialize(); }### Answer:
@Test public void assertSerializeSimpleJob() { TaskInfoData actual = new TaskInfoData(shardingContexts, CloudJobConfigurationBuilder.createCloudJobConfiguration("test_job")); assertSerialize((Map) SerializationUtils.deserialize(actual.serialize())); }
@Test public void assertSerializeDataflowJob() { TaskInfoData actual = new TaskInfoData(shardingContexts, CloudJobConfigurationBuilder.createDataflowCloudJobConfiguration("test_job")); assertSerialize((Map) SerializationUtils.deserialize(actual.serialize())); }
@Test public void assertSerializeScriptJob() { TaskInfoData actual = new TaskInfoData(shardingContexts, CloudJobConfigurationBuilder.createScriptCloudJobConfiguration("test_job")); assertSerialize((Map) SerializationUtils.deserialize(actual.serialize())); }
|
### Question:
TaskLaunchScheduledService extends AbstractScheduledService { @Override protected Scheduler scheduler() { return Scheduler.newFixedDelaySchedule(2, 10, TimeUnit.SECONDS); } }### Answer:
@Test public void assertScheduler() throws Exception { assertThat(taskLaunchScheduledService.scheduler(), instanceOf(Scheduler.class)); }
@Test public void assertScheduler() { assertThat(taskLaunchScheduledService.scheduler(), instanceOf(Scheduler.class)); }
|
### Question:
TaskLaunchScheduledService extends AbstractScheduledService { @Override protected String serviceName() { return "task-launch-processor"; } }### Answer:
@Test public void assertServiceName() throws Exception { assertThat(taskLaunchScheduledService.serviceName(), is("task-launch-processor")); }
@Test public void assertServiceName() { assertThat(taskLaunchScheduledService.serviceName(), is("task-launch-processor")); }
|
### Question:
SchedulerService { public void start() { facadeService.start(); producerManager.startup(); statisticManager.startup(); cloudJobConfigurationListener.start(); taskLaunchScheduledService.startAsync(); restfulService.start(); schedulerDriver.start(); if (env.getFrameworkConfiguration().isEnabledReconcile()) { reconcileService.startAsync(); } } SchedulerService(final CoordinatorRegistryCenter regCenter); void start(); void stop(); }### Answer:
@Test public void assertStart() { setReconcileEnabled(true); schedulerService.start(); InOrder inOrder = getInOrder(); inOrder.verify(facadeService).start(); inOrder.verify(producerManager).startup(); inOrder.verify(statisticManager).startup(); inOrder.verify(cloudJobConfigurationListener).start(); inOrder.verify(taskLaunchScheduledService).startAsync(); inOrder.verify(restfulService).start(); inOrder.verify(schedulerDriver).start(); inOrder.verify(reconcileService).startAsync(); }
@Test public void assertStartWithoutReconcile() { setReconcileEnabled(false); schedulerService.start(); InOrder inOrder = getInOrder(); inOrder.verify(facadeService).start(); inOrder.verify(producerManager).startup(); inOrder.verify(statisticManager).startup(); inOrder.verify(cloudJobConfigurationListener).start(); inOrder.verify(taskLaunchScheduledService).startAsync(); inOrder.verify(restfulService).start(); inOrder.verify(schedulerDriver).start(); inOrder.verify(reconcileService, never()).stopAsync(); }
|
### Question:
SchedulerService { public void stop() { restfulService.stop(); taskLaunchScheduledService.stopAsync(); cloudJobConfigurationListener.stop(); statisticManager.shutdown(); producerManager.shutdown(); schedulerDriver.stop(true); facadeService.stop(); if (env.getFrameworkConfiguration().isEnabledReconcile()) { reconcileService.stopAsync(); } } SchedulerService(final CoordinatorRegistryCenter regCenter); void start(); void stop(); }### Answer:
@Test public void assertStop() { setReconcileEnabled(true); schedulerService.stop(); InOrder inOrder = getInOrder(); inOrder.verify(restfulService).stop(); inOrder.verify(taskLaunchScheduledService).stopAsync(); inOrder.verify(cloudJobConfigurationListener).stop(); inOrder.verify(statisticManager).shutdown(); inOrder.verify(producerManager).shutdown(); inOrder.verify(schedulerDriver).stop(true); inOrder.verify(facadeService).stop(); inOrder.verify(reconcileService).stopAsync(); }
@Test public void assertStopWithoutReconcile() { setReconcileEnabled(false); schedulerService.stop(); InOrder inOrder = getInOrder(); inOrder.verify(restfulService).stop(); inOrder.verify(taskLaunchScheduledService).stopAsync(); inOrder.verify(cloudJobConfigurationListener).stop(); inOrder.verify(statisticManager).shutdown(); inOrder.verify(producerManager).shutdown(); inOrder.verify(schedulerDriver).stop(true); inOrder.verify(facadeService).stop(); inOrder.verify(reconcileService, never()).stopAsync(); }
|
### Question:
JobConfigurationContext implements JobRootConfiguration { @Override public JobTypeConfiguration getTypeConfig() { return jobTypeConfig; } JobConfigurationContext(final Map<String, String> jobConfigurationMap); boolean isTransient(); @Override JobTypeConfiguration getTypeConfig(); }### Answer:
@Test public void assertSimpleJobConfigurationContext() throws JobExecutionEnvironmentException { Assert.assertTrue(new JobConfigurationContext(buildJobConfigurationContextMap(JobType.SIMPLE)).getTypeConfig() instanceof SimpleJobConfiguration); }
@Test public void assertDataflowJobConfigurationContext() throws JobExecutionEnvironmentException { Assert.assertTrue(new JobConfigurationContext(buildJobConfigurationContextMap(JobType.DATAFLOW)).getTypeConfig() instanceof DataflowJobConfiguration); }
@Test public void assertScriptJobConfigurationContext() throws JobExecutionEnvironmentException { Assert.assertTrue(new JobConfigurationContext(buildJobConfigurationContextMap(JobType.SCRIPT)).getTypeConfig() instanceof ScriptJobConfiguration); }
|
### Question:
LaunchingTasks { List<TaskRequest> getPendingTasks() { List<TaskRequest> result = new ArrayList<>(eligibleJobContextsMap.size() * 10); for (JobContext each : eligibleJobContextsMap.values()) { result.addAll(createTaskRequests(each)); } return result; } LaunchingTasks(final Collection<JobContext> eligibleJobContexts); }### Answer:
@Test public void assertGetPendingTasks() { List<TaskRequest> actual = launchingTasks.getPendingTasks(); Assert.assertThat(actual.size(), Is.is(20)); }
@Test public void assertGetPendingTasks() { List<TaskRequest> actual = launchingTasks.getPendingTasks(); assertThat(actual.size(), is(20)); }
|
### Question:
JobContext { public static JobContext from(final CloudJobConfiguration jobConfig, final ExecutionType type) { int shardingTotalCount = jobConfig.getTypeConfig().getCoreConfig().getShardingTotalCount(); List<Integer> shardingItems = new ArrayList<>(shardingTotalCount); for (int i = 0; i < shardingTotalCount; i++) { shardingItems.add(i); } return new JobContext(jobConfig, shardingItems, type); } static JobContext from(final CloudJobConfiguration jobConfig, final ExecutionType type); }### Answer:
@Test public void assertFrom() { CloudJobConfiguration jobConfig = CloudJobConfigurationBuilder.createCloudJobConfiguration("test_job"); JobContext actual = JobContext.from(jobConfig, ExecutionType.READY); Assert.assertThat(actual.getAssignedShardingItems().size(), Is.is(10)); for (int i = 0; i < actual.getAssignedShardingItems().size(); i++) { Assert.assertThat(actual.getAssignedShardingItems().get(i), Is.is(i)); } }
|
### Question:
BootstrapEnvironment { public MesosConfiguration getMesosConfiguration() { return new MesosConfiguration(getValue(EnvironmentArgument.USER), getValue(EnvironmentArgument.MESOS_URL), getValue(EnvironmentArgument.HOSTNAME)); } private BootstrapEnvironment(); String getFrameworkHostPort(); MesosConfiguration getMesosConfiguration(); ZookeeperConfiguration getZookeeperConfiguration(); RestfulServerConfiguration getRestfulServerConfiguration(); FrameworkConfiguration getFrameworkConfiguration(); Optional<JobEventRdbConfiguration> getJobEventRdbConfiguration(); HashMap<String, String> getJobEventRdbConfigurationMap(); Optional<String> getMesosRole(); }### Answer:
@Test public void assertGetMesosConfiguration() throws NoSuchFieldException { MesosConfiguration mesosConfig = bootstrapEnvironment.getMesosConfiguration(); Assert.assertThat(mesosConfig.getHostname(), Is.is("localhost")); Assert.assertThat(mesosConfig.getUser(), Is.is("")); Assert.assertThat(mesosConfig.getUrl(), Is.is("zk: }
|
### Question:
BootstrapEnvironment { public ZookeeperConfiguration getZookeeperConfiguration() { ZookeeperConfiguration result = new ZookeeperConfiguration(getValue(EnvironmentArgument.ZOOKEEPER_SERVERS), getValue(EnvironmentArgument.ZOOKEEPER_NAMESPACE)); String digest = getValue(EnvironmentArgument.ZOOKEEPER_DIGEST); if (!Strings.isNullOrEmpty(digest)) { result.setDigest(digest); } return result; } private BootstrapEnvironment(); String getFrameworkHostPort(); MesosConfiguration getMesosConfiguration(); ZookeeperConfiguration getZookeeperConfiguration(); RestfulServerConfiguration getRestfulServerConfiguration(); FrameworkConfiguration getFrameworkConfiguration(); Optional<JobEventRdbConfiguration> getJobEventRdbConfiguration(); HashMap<String, String> getJobEventRdbConfigurationMap(); Optional<String> getMesosRole(); }### Answer:
@Test public void assertGetZookeeperConfiguration() throws NoSuchFieldException { Properties properties = new Properties(); properties.setProperty(BootstrapEnvironment.EnvironmentArgument.ZOOKEEPER_DIGEST.getKey(), "test"); ReflectionUtils.setFieldValue(bootstrapEnvironment, "properties", properties); ZookeeperConfiguration zkConfig = bootstrapEnvironment.getZookeeperConfiguration(); Assert.assertThat(zkConfig.getServerLists(), Is.is("localhost:2181")); Assert.assertThat(zkConfig.getNamespace(), Is.is("elastic-job-cloud")); Assert.assertThat(zkConfig.getDigest(), Is.is("test")); }
|
### Question:
BootstrapEnvironment { public RestfulServerConfiguration getRestfulServerConfiguration() { return new RestfulServerConfiguration(Integer.parseInt(getValue(EnvironmentArgument.PORT))); } private BootstrapEnvironment(); String getFrameworkHostPort(); MesosConfiguration getMesosConfiguration(); ZookeeperConfiguration getZookeeperConfiguration(); RestfulServerConfiguration getRestfulServerConfiguration(); FrameworkConfiguration getFrameworkConfiguration(); Optional<JobEventRdbConfiguration> getJobEventRdbConfiguration(); HashMap<String, String> getJobEventRdbConfigurationMap(); Optional<String> getMesosRole(); }### Answer:
@Test public void assertGetRestfulServerConfiguration() { RestfulServerConfiguration restfulServerConfig = bootstrapEnvironment.getRestfulServerConfiguration(); Assert.assertThat(restfulServerConfig.getPort(), Is.is(8899)); }
|
### Question:
BootstrapEnvironment { public FrameworkConfiguration getFrameworkConfiguration() { return new FrameworkConfiguration(Integer.parseInt(getValue(EnvironmentArgument.JOB_STATE_QUEUE_SIZE)), Integer.parseInt(getValue(EnvironmentArgument.RECONCILE_INTERVAL_MINUTES))); } private BootstrapEnvironment(); String getFrameworkHostPort(); MesosConfiguration getMesosConfiguration(); ZookeeperConfiguration getZookeeperConfiguration(); RestfulServerConfiguration getRestfulServerConfiguration(); FrameworkConfiguration getFrameworkConfiguration(); Optional<JobEventRdbConfiguration> getJobEventRdbConfiguration(); HashMap<String, String> getJobEventRdbConfigurationMap(); Optional<String> getMesosRole(); }### Answer:
@Test public void assertGetFrameworkConfiguration() { FrameworkConfiguration frameworkConfig = bootstrapEnvironment.getFrameworkConfiguration(); Assert.assertThat(frameworkConfig.getJobStateQueueSize(), Is.is(10000)); }
@Test public void assertReconcileConfiguration() throws NoSuchFieldException { FrameworkConfiguration configuration = bootstrapEnvironment.getFrameworkConfiguration(); Assert.assertThat(configuration.getReconcileIntervalMinutes(), Is.is(-1)); Assert.assertFalse(configuration.isEnabledReconcile()); Properties properties = new Properties(); properties.setProperty(BootstrapEnvironment.EnvironmentArgument.RECONCILE_INTERVAL_MINUTES.getKey(), "0"); ReflectionUtils.setFieldValue(bootstrapEnvironment, "properties", properties); configuration = bootstrapEnvironment.getFrameworkConfiguration(); Assert.assertThat(configuration.getReconcileIntervalMinutes(), Is.is(0)); Assert.assertFalse(configuration.isEnabledReconcile()); }
|
### Question:
CloudAppRestfulApi { @PUT @Consumes(MediaType.APPLICATION_JSON) public void update(final CloudAppConfiguration appConfig) { appConfigService.update(appConfig); } CloudAppRestfulApi(); static void init(final CoordinatorRegistryCenter regCenter, final ProducerManager producerManager); @POST @Consumes(MediaType.APPLICATION_JSON) void register(final CloudAppConfiguration appConfig); @PUT @Consumes(MediaType.APPLICATION_JSON) void update(final CloudAppConfiguration appConfig); @GET @Path("/{appName}") @Consumes(MediaType.APPLICATION_JSON) Response detail(@PathParam("appName") final String appName); @GET @Path("/list") @Produces(MediaType.APPLICATION_JSON) Collection<CloudAppConfiguration> findAllApps(); @GET @Path("/{appName}/disable") @Produces(MediaType.APPLICATION_JSON) boolean isDisabled(@PathParam("appName") final String appName); @POST @Path("/{appName}/disable") void disable(@PathParam("appName") final String appName); @POST @Path("/{appName}/enable") void enable(@PathParam("appName") final String appName); @DELETE @Path("/{appName}") @Consumes(MediaType.APPLICATION_JSON) void deregister(@PathParam("appName") final String appName); }### Answer:
@Test public void assertUpdate() throws Exception { Mockito.when(getRegCenter().isExisted("/config/app/test_app")).thenReturn(true); Mockito.when(getRegCenter().get("/config/app/test_app")).thenReturn(CloudAppJsonConstants.getAppJson("test_app")); Assert.assertThat(RestfulTestsUtil.sentRequest("http: Mockito.verify(getRegCenter()).update("/config/app/test_app", CloudAppJsonConstants.getAppJson("test_app")); }
|
### Question:
JobConfigurationContext implements JobRootConfiguration { public boolean isTransient() { return IGNORE_CRON.equals(jobTypeConfig.getCoreConfig().getCron()); } JobConfigurationContext(final Map<String, String> jobConfigurationMap); boolean isTransient(); @Override JobTypeConfiguration getTypeConfig(); }### Answer:
@Test public void assertSimpleJobConfigurationContextWithExecutionType() throws JobExecutionEnvironmentException { Map<String, String> context = buildJobConfigurationContextMap(JobType.SIMPLE); Assert.assertTrue(new JobConfigurationContext(context).isTransient()); context.put("cron", "0/1 * * * * ?"); Assert.assertFalse(new JobConfigurationContext(context).isTransient()); }
|
### Question:
ExceptionUtil { public static String transform(final Throwable cause) { if (null == cause) { return ""; } StringWriter result = new StringWriter(); try (PrintWriter writer = new PrintWriter(result)) { cause.printStackTrace(writer); } return result.toString(); } static String transform(final Throwable cause); }### Answer:
@Test public void assertTransformWithError() { Assert.assertTrue(ExceptionUtil.transform(new Error("Error")).startsWith("java.lang.Error")); }
@Test public void assertTransformWithException() { Assert.assertTrue(ExceptionUtil.transform(new Exception("Exception")).startsWith("java.lang.Exception")); }
@Test public void assertTransformWithNull() { Assert.assertThat(ExceptionUtil.transform(null), Is.is("")); }
|
### Question:
JobProperties { public void put(final String key, final String value) { JobPropertiesEnum jobPropertiesEnum = JobPropertiesEnum.from(key); if (null == jobPropertiesEnum || null == value) { return; } map.put(jobPropertiesEnum, value); } void put(final String key, final String value); String get(final JobPropertiesEnum jobPropertiesEnum); String json(); }### Answer:
@Test public void assertPutInvalidKey() throws NoSuchFieldException { JobProperties actual = new JobProperties(); actual.put("invalid_key", ""); Assert.assertTrue(getMap(actual).isEmpty()); }
@Test public void assertPutNullValue() throws NoSuchFieldException { JobProperties actual = new JobProperties(); actual.put(JobProperties.JobPropertiesEnum.JOB_EXCEPTION_HANDLER.getKey(), null); Assert.assertTrue(getMap(actual).isEmpty()); }
@Test public void assertPutSuccess() throws NoSuchFieldException { JobProperties actual = new JobProperties(); actual.put(JobProperties.JobPropertiesEnum.JOB_EXCEPTION_HANDLER.getKey(), DefaultJobExceptionHandler.class.getCanonicalName()); Assert.assertThat(getMap(actual).size(), Is.is(1)); }
|
### Question:
CloudJobFacade implements JobFacade { @Override public void registerJobBegin(final ShardingContexts shardingContexts) { } @Override JobRootConfiguration loadJobRootConfiguration(final boolean fromCache); @Override void checkJobExecutionEnvironment(); @Override void failoverIfNecessary(); @Override void registerJobBegin(final ShardingContexts shardingContexts); @Override void registerJobCompleted(final ShardingContexts shardingContexts); ShardingContexts getShardingContexts(); @Override boolean misfireIfRunning(final Collection<Integer> shardingItems); @Override void clearMisfire(final Collection<Integer> shardingItems); @Override boolean isExecuteMisfired(final Collection<Integer> shardingItems); @Override boolean isEligibleForJobRunning(); @Override boolean isNeedSharding(); @Override void beforeJobExecuted(final ShardingContexts shardingContexts); @Override void afterJobExecuted(final ShardingContexts shardingContexts); @Override void postJobExecutionEvent(final JobExecutionEvent jobExecutionEvent); @Override void postJobStatusTraceEvent(final String taskId, final JobStatusTraceEvent.State state, final String message); }### Answer:
@Test public void assertRegisterJobBegin() { jobFacade.registerJobBegin(null); }
|
### Question:
JobProperties { public String get(final JobPropertiesEnum jobPropertiesEnum) { return map.containsKey(jobPropertiesEnum) ? map.get(jobPropertiesEnum) : jobPropertiesEnum.getDefaultValue(); } void put(final String key, final String value); String get(final JobPropertiesEnum jobPropertiesEnum); String json(); }### Answer:
@Test public void assertGetWhenValueIsEmpty() throws NoSuchFieldException { JobProperties actual = new JobProperties(); Assert.assertThat(actual.get(JobProperties.JobPropertiesEnum.JOB_EXCEPTION_HANDLER), Is.is(DefaultJobExceptionHandler.class.getCanonicalName())); Assert.assertThat(actual.get(JobProperties.JobPropertiesEnum.EXECUTOR_SERVICE_HANDLER), Is.is(DefaultExecutorServiceHandler.class.getCanonicalName())); }
|
### Question:
JobProperties { public String json() { Map<String, String> jsonMap = new LinkedHashMap<>(JobPropertiesEnum.values().length, 1); for (JobPropertiesEnum each : JobPropertiesEnum.values()) { jsonMap.put(each.getKey(), get(each)); } return GsonFactory.getGson().toJson(jsonMap); } void put(final String key, final String value); String get(final JobPropertiesEnum jobPropertiesEnum); String json(); }### Answer:
@Test public void assertJson() { Assert.assertThat(new JobProperties().json(), Is.is(APIJsonConstants.getJobPropertiesJson(DefaultJobExceptionHandler.class.getCanonicalName()))); }
|
### Question:
ExecutorServiceHandlerRegistry { public static synchronized ExecutorService getExecutorServiceHandler(final String jobName, final ExecutorServiceHandler executorServiceHandler) { if (!REGISTRY.containsKey(jobName)) { REGISTRY.put(jobName, executorServiceHandler.createExecutorService(jobName)); } return REGISTRY.get(jobName); } static synchronized ExecutorService getExecutorServiceHandler(final String jobName, final ExecutorServiceHandler executorServiceHandler); static synchronized void remove(final String jobName); }### Answer:
@Test public void assertGetExecutorServiceHandlerForSameThread() { Assert.assertThat(ExecutorServiceHandlerRegistry.getExecutorServiceHandler("test_job", new DefaultExecutorServiceHandler()), Is.is(ExecutorServiceHandlerRegistry.getExecutorServiceHandler("test_job", new DefaultExecutorServiceHandler()))); }
@Test public void assertGetExecutorServiceHandlerForConcurrent() throws InterruptedException { int threadCount = 100; CyclicBarrier barrier = new CyclicBarrier(threadCount); ExecutorService executorService = Executors.newFixedThreadPool(threadCount); CountDownLatch latch = new CountDownLatch(threadCount); Set<ExecutorService> set = new CopyOnWriteArraySet<>(); for (int i = 0; i < threadCount; i++) { executorService.submit(new GetExecutorServiceHandlerTask(barrier, latch, set)); } latch.await(); Assert.assertThat(set.size(), Is.is(1)); Assert.assertThat(ExecutorServiceHandlerRegistry.getExecutorServiceHandler("test_job", new DefaultExecutorServiceHandler()), Is.is(set.iterator().next())); }
|
### Question:
DefaultJobExceptionHandler implements JobExceptionHandler { @Override public void handleException(final String jobName, final Throwable cause) { log.error(String.format("Job '%s' exception occur in job processing", jobName), cause); } @Override void handleException(final String jobName, final Throwable cause); }### Answer:
@Test public void assertHandleException() { new DefaultJobExceptionHandler().handleException("test_job", new RuntimeException("test")); verify(caller, atMost(1)).call(); }
|
### Question:
CloudJobFacade implements JobFacade { @Override public void registerJobCompleted(final ShardingContexts shardingContexts) { } @Override JobRootConfiguration loadJobRootConfiguration(final boolean fromCache); @Override void checkJobExecutionEnvironment(); @Override void failoverIfNecessary(); @Override void registerJobBegin(final ShardingContexts shardingContexts); @Override void registerJobCompleted(final ShardingContexts shardingContexts); ShardingContexts getShardingContexts(); @Override boolean misfireIfRunning(final Collection<Integer> shardingItems); @Override void clearMisfire(final Collection<Integer> shardingItems); @Override boolean isExecuteMisfired(final Collection<Integer> shardingItems); @Override boolean isEligibleForJobRunning(); @Override boolean isNeedSharding(); @Override void beforeJobExecuted(final ShardingContexts shardingContexts); @Override void afterJobExecuted(final ShardingContexts shardingContexts); @Override void postJobExecutionEvent(final JobExecutionEvent jobExecutionEvent); @Override void postJobStatusTraceEvent(final String taskId, final JobStatusTraceEvent.State state, final String message); }### Answer:
@Test public void assertRegisterJobCompleted() { jobFacade.registerJobCompleted(null); }
|
### Question:
StatisticRdbRepository { public Optional<TaskResultStatistics> findLatestTaskResultStatistics(final StatisticInterval statisticInterval) { TaskResultStatistics result = null; String sql = String.format("SELECT id, success_count, failed_count, statistics_time, creation_time FROM %s order by id DESC LIMIT 1", TABLE_TASK_RESULT_STATISTICS + "_" + statisticInterval); try ( Connection conn = dataSource.getConnection(); PreparedStatement preparedStatement = conn.prepareStatement(sql); ResultSet resultSet = preparedStatement.executeQuery() ) { while (resultSet.next()) { result = new TaskResultStatistics(resultSet.getLong(1), resultSet.getInt(2), resultSet.getInt(3), statisticInterval, new Date(resultSet.getTimestamp(4).getTime()), new Date(resultSet.getTimestamp(5).getTime())); } } catch (final SQLException ex) { log.error("Fetch latest taskResultStatistics from DB error:", ex); } return Optional.fromNullable(result); } StatisticRdbRepository(final DataSource dataSource); boolean add(final TaskResultStatistics taskResultStatistics); boolean add(final TaskRunningStatistics taskRunningStatistics); boolean add(final JobRunningStatistics jobRunningStatistics); boolean add(final JobRegisterStatistics jobRegisterStatistics); List<TaskResultStatistics> findTaskResultStatistics(final Date from, final StatisticInterval statisticInterval); TaskResultStatistics getSummedTaskResultStatistics(final Date from, final StatisticInterval statisticInterval); Optional<TaskResultStatistics> findLatestTaskResultStatistics(final StatisticInterval statisticInterval); List<TaskRunningStatistics> findTaskRunningStatistics(final Date from); List<JobRunningStatistics> findJobRunningStatistics(final Date from); Optional<TaskRunningStatistics> findLatestTaskRunningStatistics(); Optional<JobRunningStatistics> findLatestJobRunningStatistics(); List<JobRegisterStatistics> findJobRegisterStatistics(final Date from); Optional<JobRegisterStatistics> findLatestJobRegisterStatistics(); }### Answer:
@Test public void assertFindLatestTaskResultStatisticsWhenTableIsEmpty() { for (StatisticInterval each : StatisticInterval.values()) { Assert.assertFalse(repository.findLatestTaskResultStatistics(each).isPresent()); } }
|
### Question:
StatisticRdbRepository { public Optional<TaskRunningStatistics> findLatestTaskRunningStatistics() { TaskRunningStatistics result = null; String sql = String.format("SELECT id, running_count, statistics_time, creation_time FROM %s order by id DESC LIMIT 1", TABLE_TASK_RUNNING_STATISTICS); try ( Connection conn = dataSource.getConnection(); PreparedStatement preparedStatement = conn.prepareStatement(sql); ResultSet resultSet = preparedStatement.executeQuery() ) { while (resultSet.next()) { result = new TaskRunningStatistics(resultSet.getLong(1), resultSet.getInt(2), new Date(resultSet.getTimestamp(3).getTime()), new Date(resultSet.getTimestamp(4).getTime())); } } catch (final SQLException ex) { log.error("Fetch latest taskRunningStatistics from DB error:", ex); } return Optional.fromNullable(result); } StatisticRdbRepository(final DataSource dataSource); boolean add(final TaskResultStatistics taskResultStatistics); boolean add(final TaskRunningStatistics taskRunningStatistics); boolean add(final JobRunningStatistics jobRunningStatistics); boolean add(final JobRegisterStatistics jobRegisterStatistics); List<TaskResultStatistics> findTaskResultStatistics(final Date from, final StatisticInterval statisticInterval); TaskResultStatistics getSummedTaskResultStatistics(final Date from, final StatisticInterval statisticInterval); Optional<TaskResultStatistics> findLatestTaskResultStatistics(final StatisticInterval statisticInterval); List<TaskRunningStatistics> findTaskRunningStatistics(final Date from); List<JobRunningStatistics> findJobRunningStatistics(final Date from); Optional<TaskRunningStatistics> findLatestTaskRunningStatistics(); Optional<JobRunningStatistics> findLatestJobRunningStatistics(); List<JobRegisterStatistics> findJobRegisterStatistics(final Date from); Optional<JobRegisterStatistics> findLatestJobRegisterStatistics(); }### Answer:
@Test public void assertFindLatestTaskRunningStatisticsWhenTableIsEmpty() { Assert.assertFalse(repository.findLatestTaskRunningStatistics().isPresent()); }
|
### Question:
CloudJobFacade implements JobFacade { public ShardingContexts getShardingContexts() { return shardingContexts; } @Override JobRootConfiguration loadJobRootConfiguration(final boolean fromCache); @Override void checkJobExecutionEnvironment(); @Override void failoverIfNecessary(); @Override void registerJobBegin(final ShardingContexts shardingContexts); @Override void registerJobCompleted(final ShardingContexts shardingContexts); ShardingContexts getShardingContexts(); @Override boolean misfireIfRunning(final Collection<Integer> shardingItems); @Override void clearMisfire(final Collection<Integer> shardingItems); @Override boolean isExecuteMisfired(final Collection<Integer> shardingItems); @Override boolean isEligibleForJobRunning(); @Override boolean isNeedSharding(); @Override void beforeJobExecuted(final ShardingContexts shardingContexts); @Override void afterJobExecuted(final ShardingContexts shardingContexts); @Override void postJobExecutionEvent(final JobExecutionEvent jobExecutionEvent); @Override void postJobStatusTraceEvent(final String taskId, final JobStatusTraceEvent.State state, final String message); }### Answer:
@Test public void assertGetShardingContext() { assertThat(jobFacade.getShardingContexts(), is(shardingContexts)); }
|
### Question:
StatisticRdbRepository { public Optional<JobRunningStatistics> findLatestJobRunningStatistics() { JobRunningStatistics result = null; String sql = String.format("SELECT id, running_count, statistics_time, creation_time FROM %s order by id DESC LIMIT 1", TABLE_JOB_RUNNING_STATISTICS); try ( Connection conn = dataSource.getConnection(); PreparedStatement preparedStatement = conn.prepareStatement(sql); ResultSet resultSet = preparedStatement.executeQuery() ) { while (resultSet.next()) { result = new JobRunningStatistics(resultSet.getLong(1), resultSet.getInt(2), new Date(resultSet.getTimestamp(3).getTime()), new Date(resultSet.getTimestamp(4).getTime())); } } catch (final SQLException ex) { log.error("Fetch latest jobRunningStatistics from DB error:", ex); } return Optional.fromNullable(result); } StatisticRdbRepository(final DataSource dataSource); boolean add(final TaskResultStatistics taskResultStatistics); boolean add(final TaskRunningStatistics taskRunningStatistics); boolean add(final JobRunningStatistics jobRunningStatistics); boolean add(final JobRegisterStatistics jobRegisterStatistics); List<TaskResultStatistics> findTaskResultStatistics(final Date from, final StatisticInterval statisticInterval); TaskResultStatistics getSummedTaskResultStatistics(final Date from, final StatisticInterval statisticInterval); Optional<TaskResultStatistics> findLatestTaskResultStatistics(final StatisticInterval statisticInterval); List<TaskRunningStatistics> findTaskRunningStatistics(final Date from); List<JobRunningStatistics> findJobRunningStatistics(final Date from); Optional<TaskRunningStatistics> findLatestTaskRunningStatistics(); Optional<JobRunningStatistics> findLatestJobRunningStatistics(); List<JobRegisterStatistics> findJobRegisterStatistics(final Date from); Optional<JobRegisterStatistics> findLatestJobRegisterStatistics(); }### Answer:
@Test public void assertFindLatestJobRunningStatisticsWhenTableIsEmpty() { Assert.assertFalse(repository.findLatestJobRunningStatistics().isPresent()); }
|
### Question:
StatisticRdbRepository { public Optional<JobRegisterStatistics> findLatestJobRegisterStatistics() { JobRegisterStatistics result = null; String sql = String.format("SELECT id, registered_count, statistics_time, creation_time FROM %s order by id DESC LIMIT 1", TABLE_JOB_REGISTER_STATISTICS); try ( Connection conn = dataSource.getConnection(); PreparedStatement preparedStatement = conn.prepareStatement(sql); ResultSet resultSet = preparedStatement.executeQuery() ) { while (resultSet.next()) { result = new JobRegisterStatistics(resultSet.getLong(1), resultSet.getInt(2), new Date(resultSet.getTimestamp(3).getTime()), new Date(resultSet.getTimestamp(4).getTime())); } } catch (final SQLException ex) { log.error("Fetch latest jobRegisterStatistics from DB error:", ex); } return Optional.fromNullable(result); } StatisticRdbRepository(final DataSource dataSource); boolean add(final TaskResultStatistics taskResultStatistics); boolean add(final TaskRunningStatistics taskRunningStatistics); boolean add(final JobRunningStatistics jobRunningStatistics); boolean add(final JobRegisterStatistics jobRegisterStatistics); List<TaskResultStatistics> findTaskResultStatistics(final Date from, final StatisticInterval statisticInterval); TaskResultStatistics getSummedTaskResultStatistics(final Date from, final StatisticInterval statisticInterval); Optional<TaskResultStatistics> findLatestTaskResultStatistics(final StatisticInterval statisticInterval); List<TaskRunningStatistics> findTaskRunningStatistics(final Date from); List<JobRunningStatistics> findJobRunningStatistics(final Date from); Optional<TaskRunningStatistics> findLatestTaskRunningStatistics(); Optional<JobRunningStatistics> findLatestJobRunningStatistics(); List<JobRegisterStatistics> findJobRegisterStatistics(final Date from); Optional<JobRegisterStatistics> findLatestJobRegisterStatistics(); }### Answer:
@Test public void assertFindLatestJobRegisterStatisticsWhenTableIsEmpty() { Assert.assertFalse(repository.findLatestJobRegisterStatistics().isPresent()); }
|
### Question:
GsonFactory { public static Gson getGson() { return gson; } static synchronized void registerTypeAdapter(final Type type, final TypeAdapter typeAdapter); static Gson getGson(); }### Answer:
@Test public void assertGetGson() { assertThat(GsonFactory.getGson(), is(GsonFactory.getGson())); }
|
### Question:
Encryption { public static String md5(final String str) { try { MessageDigest messageDigest = MessageDigest.getInstance(MD5); messageDigest.update(str.getBytes()); return new BigInteger(1, messageDigest.digest()).toString(16); } catch (final NoSuchAlgorithmException ex) { throw new JobSystemException(ex); } } static String md5(final String str); }### Answer:
@Test public void assertMd5() { Assert.assertThat(Encryption.md5("test"), Is.is("98f6bcd4621d373cade4e832627b4f6")); }
|
### Question:
ShardingItems { public static List<Integer> toItemList(final String itemsString) { if (Strings.isNullOrEmpty(itemsString)) { return Collections.emptyList(); } String[] items = itemsString.split(DELIMITER); List<Integer> result = new ArrayList<>(items.length); for (String each : items) { int item = Integer.parseInt(each); if (!result.contains(item)) { result.add(item); } } return result; } static List<Integer> toItemList(final String itemsString); static String toItemsString(final List<Integer> items); }### Answer:
@Test public void assertTtoItemListWhenNull() { assertThat(ShardingItems.toItemList(null), is(Collections.EMPTY_LIST)); }
@Test public void assertToItemListWhenEmpty() { assertThat(ShardingItems.toItemList(""), is(Collections.EMPTY_LIST)); }
@Test public void assertToItemList() { assertThat(ShardingItems.toItemList("0,1,2"), is(Arrays.asList(0, 1, 2))); }
@Test public void assertToItemListForDuplicated() { assertThat(ShardingItems.toItemList("0,1,2,2"), is(Arrays.asList(0, 1, 2))); }
|
### Question:
CloudJobFacade implements JobFacade { @Override public boolean misfireIfRunning(final Collection<Integer> shardingItems) { return false; } @Override JobRootConfiguration loadJobRootConfiguration(final boolean fromCache); @Override void checkJobExecutionEnvironment(); @Override void failoverIfNecessary(); @Override void registerJobBegin(final ShardingContexts shardingContexts); @Override void registerJobCompleted(final ShardingContexts shardingContexts); ShardingContexts getShardingContexts(); @Override boolean misfireIfRunning(final Collection<Integer> shardingItems); @Override void clearMisfire(final Collection<Integer> shardingItems); @Override boolean isExecuteMisfired(final Collection<Integer> shardingItems); @Override boolean isEligibleForJobRunning(); @Override boolean isNeedSharding(); @Override void beforeJobExecuted(final ShardingContexts shardingContexts); @Override void afterJobExecuted(final ShardingContexts shardingContexts); @Override void postJobExecutionEvent(final JobExecutionEvent jobExecutionEvent); @Override void postJobStatusTraceEvent(final String taskId, final JobStatusTraceEvent.State state, final String message); }### Answer:
@Test public void assertMisfireIfNecessary() { jobFacade.misfireIfRunning(null); }
|
### Question:
ShardingItems { public static String toItemsString(final List<Integer> items) { return items.isEmpty() ? "" : Joiner.on(DELIMITER).join(items); } static List<Integer> toItemList(final String itemsString); static String toItemsString(final List<Integer> items); }### Answer:
@Test public void assertToItemsStringWhenEmpty() { assertThat(ShardingItems.toItemsString(Collections.<Integer>emptyList()), is("")); }
@Test public void assertToItemsString() { assertThat(ShardingItems.toItemsString(Arrays.asList(0, 1, 2)), is("0,1,2")); }
|
### Question:
IpUtils { public static String getIp() { if (null != cachedIpAddress) { return cachedIpAddress; } Enumeration<NetworkInterface> netInterfaces; try { netInterfaces = NetworkInterface.getNetworkInterfaces(); } catch (final SocketException ex) { throw new HostException(ex); } String localIpAddress = null; while (netInterfaces.hasMoreElements()) { NetworkInterface netInterface = netInterfaces.nextElement(); Enumeration<InetAddress> ipAddresses = netInterface.getInetAddresses(); while (ipAddresses.hasMoreElements()) { InetAddress ipAddress = ipAddresses.nextElement(); if (isPublicIpAddress(ipAddress)) { String publicIpAddress = ipAddress.getHostAddress(); cachedIpAddress = publicIpAddress; return publicIpAddress; } if (isLocalIpAddress(ipAddress)) { localIpAddress = ipAddress.getHostAddress(); } } } cachedIpAddress = localIpAddress; return localIpAddress; } static String getIp(); static String getHostName(); static final String IP_REGEX; }### Answer:
@Test public void assertGetIp() { assertNotNull(IpUtils.getIp()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.