@Test public void testAttachDiskNameIndexWithOptions() throws Exception { initializeExpectedInstance(2); expect(compute.getOptions()).andReturn(mockOptions); AttachedDisk.PersistentDiskConfiguration configuration = AttachedDisk.PersistentDiskConfiguration.of(DISK_ID); Operation operation = new Operation.Builder(serviceMockReturnsOptions) .setOperationId(ZoneOperationId.of("project", "op")) .build(); expect( compute.attachDisk( INSTANCE_ID, "dev0", configuration, 1, Compute.OperationOption.fields())) .andReturn(operation); replay(compute); initializeInstance(); assertSame( operation, instance.attachDisk("dev0", configuration, 1, Compute.OperationOption.fields())); }
@Override public boolean equals(Object obj) { return obj == this || obj != null && obj.getClass().equals(PersistentDiskConfiguration.class) && baseEquals((PersistentDiskConfiguration) obj); }
@Override public int hashCode() { return Objects.hash(baseHashCode(), sourceDisk, mode); }
AttachedDisk.PersistentDiskConfiguration remoteConfiguration = remoteInstance.getAttachedDisks().get(0).getConfiguration(); assertEquals(instanceName, remoteConfiguration.getSourceDisk().getDisk()); assertEquals(ZONE, remoteConfiguration.getSourceDisk().getZone()); assertTrue(remoteConfiguration.boot()); assertTrue(remoteConfiguration.autoDelete()); assertEquals(1, remoteInstance.getNetworkInterfaces().size()); NetworkInterface remoteNetworkInterface = remoteInstance.getNetworkInterfaces().get(0);
"dev1", AttachedDisk.PersistentDiskConfiguration.newBuilder(diskId).build()); instanceOperation.waitFor(); remoteInstance = compute.getInstance(instanceId);
NetworkId networkId = NetworkId.of("default"); PersistentDiskConfiguration attachConfiguration = PersistentDiskConfiguration.newBuilder(diskId).setBoot(true).build(); AttachedDisk attachedDisk = AttachedDisk.of("dev0", attachConfiguration); NetworkInterface networkInterface =
@Test public void testSetProjectId() { PersistentDiskConfiguration persistentConfiguration = PersistentDiskConfiguration.of(DiskId.of("zone", "disk")); PersistentDiskConfiguration persistentConfigurationWithProject = PersistentDiskConfiguration.of(DiskId.of("project", "zone", "disk")); AttachedDisk attachedDisk = AttachedDisk.of(persistentConfiguration); compareAttachedDisk(
@Test public void testConfigurationToAndFromPb() { PersistentDiskConfiguration persistentConfiguration = PersistentDiskConfiguration.of(DISK_ID); comparePersistentDiskConfiguration( persistentConfiguration, AttachedDisk.AttachedDiskConfiguration.<PersistentDiskConfiguration>fromPb( persistentConfiguration.toPb())); comparePersistentDiskConfiguration( PERSISTENT_DISK_CONFIGURATION, AttachedDisk.AttachedDiskConfiguration.<PersistentDiskConfiguration>fromPb( PERSISTENT_DISK_CONFIGURATION.toPb())); ScratchDiskConfiguration scratchDiskConfiguration = ScratchDiskConfiguration.of(DISK_TYPE_ID); compareScratchDiskConfiguration( scratchDiskConfiguration, AttachedDisk.AttachedDiskConfiguration.<ScratchDiskConfiguration>fromPb( scratchDiskConfiguration.toPb())); compareScratchDiskConfiguration( SCRATCH_DISK_CONFIGURATION, AttachedDisk.AttachedDiskConfiguration.<ScratchDiskConfiguration>fromPb( SCRATCH_DISK_CONFIGURATION.toPb())); CreateDiskConfiguration createDiskConfiguration = CreateDiskConfiguration.of(IMAGE_ID); compareCreateDiskConfiguration( createDiskConfiguration, AttachedDisk.AttachedDiskConfiguration.<CreateDiskConfiguration>fromPb( createDiskConfiguration.toPb())); compareCreateDiskConfiguration( CREATE_DISK_CONFIGURATION, AttachedDisk.AttachedDiskConfiguration.<CreateDiskConfiguration>fromPb( CREATE_DISK_CONFIGURATION.toPb())); }
@Test public void testConfigurationOf() { PersistentDiskConfiguration persistentConfiguration = PersistentDiskConfiguration.of(DISK_ID); assertEquals(DISK_ID, persistentConfiguration.getSourceDisk()); assertEquals(Type.PERSISTENT, persistentConfiguration.getType()); assertNull(persistentConfiguration.autoDelete()); assertNull(persistentConfiguration.boot()); assertNull(persistentConfiguration.getInterfaceType()); ScratchDiskConfiguration scratchDiskConfiguration = ScratchDiskConfiguration.of(DISK_TYPE_ID); assertEquals(DISK_TYPE_ID, scratchDiskConfiguration.getDiskType()); assertNull(scratchDiskConfiguration.getInterfaceType()); assertEquals(Type.SCRATCH, scratchDiskConfiguration.getType()); assertTrue(scratchDiskConfiguration.autoDelete()); assertFalse(scratchDiskConfiguration.boot()); assertNull(scratchDiskConfiguration.getInterfaceType()); CreateDiskConfiguration createDiskConfiguration = CreateDiskConfiguration.of(IMAGE_ID); assertEquals(IMAGE_ID, createDiskConfiguration.getSourceImage()); assertNull(createDiskConfiguration.getDiskType()); assertNull(createDiskConfiguration.getDiskName()); assertNull(createDiskConfiguration.getDiskSizeGb()); assertNull(createDiskConfiguration.getInterfaceType()); assertEquals(Type.PERSISTENT, createDiskConfiguration.getType()); assertNull(createDiskConfiguration.autoDelete()); assertTrue(createDiskConfiguration.boot()); assertNull(createDiskConfiguration.getInterfaceType()); }
@Test public void testConfigurationToBuilder() { comparePersistentDiskConfiguration( PERSISTENT_DISK_CONFIGURATION, PERSISTENT_DISK_CONFIGURATION.toBuilder().build()); compareScratchDiskConfiguration( SCRATCH_DISK_CONFIGURATION, SCRATCH_DISK_CONFIGURATION.toBuilder().build()); compareCreateDiskConfiguration( CREATE_DISK_CONFIGURATION, CREATE_DISK_CONFIGURATION.toBuilder().build()); PersistentDiskConfiguration persistentDiskConfiguration = PERSISTENT_DISK_CONFIGURATION.toBuilder().setAutoDelete(false).build(); assertFalse(persistentDiskConfiguration.autoDelete()); persistentDiskConfiguration = persistentDiskConfiguration.toBuilder().setAutoDelete(AUTO_DELETE).build(); assertEquals(PERSISTENT_DISK_CONFIGURATION, persistentDiskConfiguration); ScratchDiskConfiguration scratchDiskConfiguration = SCRATCH_DISK_CONFIGURATION.toBuilder().setInterfaceType(InterfaceType.SCSI).build(); assertEquals(InterfaceType.SCSI, scratchDiskConfiguration.getInterfaceType()); scratchDiskConfiguration = scratchDiskConfiguration.toBuilder().setInterfaceType(INTERFACE_TYPE).build(); assertEquals(SCRATCH_DISK_CONFIGURATION, scratchDiskConfiguration); CreateDiskConfiguration createDiskConfiguration = CREATE_DISK_CONFIGURATION.toBuilder().setAutoDelete(false).build(); assertFalse(createDiskConfiguration.autoDelete()); createDiskConfiguration = createDiskConfiguration.toBuilder().setAutoDelete(AUTO_DELETE).build(); assertEquals(CREATE_DISK_CONFIGURATION, createDiskConfiguration); }
@Test public void testConfigurationSetProjectId() { PersistentDiskConfiguration persistentConfiguration = PersistentDiskConfiguration.of(DiskId.of("zone", "disk")); comparePersistentDiskConfiguration( PersistentDiskConfiguration.of(DiskId.of("project", "zone", "disk")), persistentConfiguration.setProjectId("project")); ScratchDiskConfiguration scratchDiskConfiguration = ScratchDiskConfiguration.of(DiskTypeId.of("zone", "diskType")); compareScratchDiskConfiguration( ScratchDiskConfiguration.of(DiskTypeId.of("project", "zone", "diskType")), scratchDiskConfiguration.setProjectId("project")); CreateDiskConfiguration createDiskConfiguration = CREATE_DISK_CONFIGURATION .toBuilder() .setDiskType(DiskTypeId.of("zone", "diskType")) .setSourceImage(ImageId.of("image")) .build(); compareCreateDiskConfiguration( CREATE_DISK_CONFIGURATION, createDiskConfiguration.setProjectId("project")); }
@Override InstanceInfo parse(String... args) throws Exception { String message; if (args.length == 5) { String zone = args[0]; String instance = args[1]; InstanceId instanceId = InstanceId.of(zone, instance); MachineTypeId machineTypeId = MachineTypeId.of(zone, args[2]); DiskId diskId = DiskId.of(zone, args[3]); AttachedDisk disk = AttachedDisk.of(PersistentDiskConfiguration.newBuilder(diskId).setBoot(true).build()); NetworkInterface networkInterface = NetworkInterface.of(args[4]); return InstanceInfo.of(instanceId, machineTypeId, disk, networkInterface); } else if (args.length > 5) { message = "Too many arguments."; } else { message = "Missing required arguments."; } throw new IllegalArgumentException(message); }
@Test public void testConfigurationBuilder() { assertTrue(CREATE_DISK_CONFIGURATION.boot()); assertEquals(AUTO_DELETE, CREATE_DISK_CONFIGURATION.autoDelete()); assertNull(CREATE_DISK_CONFIGURATION.getInterfaceType()); assertEquals(Type.PERSISTENT, CREATE_DISK_CONFIGURATION.getType()); assertEquals(IMAGE_ID, CREATE_DISK_CONFIGURATION.getSourceImage()); assertEquals(DISK_NAME, CREATE_DISK_CONFIGURATION.getDiskName()); assertEquals(DISK_TYPE_ID, CREATE_DISK_CONFIGURATION.getDiskType()); assertEquals(DISK_SIZE_GB, CREATE_DISK_CONFIGURATION.getDiskSizeGb()); assertEquals(IMAGE_ID, CREATE_DISK_CONFIGURATION.getSourceImage()); assertEquals(BOOT, PERSISTENT_DISK_CONFIGURATION.boot()); assertEquals(AUTO_DELETE, PERSISTENT_DISK_CONFIGURATION.autoDelete()); assertNull(PERSISTENT_DISK_CONFIGURATION.getInterfaceType()); assertEquals(Type.PERSISTENT, PERSISTENT_DISK_CONFIGURATION.getType()); assertEquals(MODE, PERSISTENT_DISK_CONFIGURATION.getMode()); assertEquals(DISK_ID, PERSISTENT_DISK_CONFIGURATION.getSourceDisk()); assertFalse(SCRATCH_DISK_CONFIGURATION.boot()); assertTrue(SCRATCH_DISK_CONFIGURATION.autoDelete()); assertEquals(INTERFACE_TYPE, SCRATCH_DISK_CONFIGURATION.getInterfaceType()); assertEquals(Type.SCRATCH, SCRATCH_DISK_CONFIGURATION.getType()); assertEquals(DISK_TYPE_ID, SCRATCH_DISK_CONFIGURATION.getDiskType()); }
@Test public void testConfigurationToBuilderIncomplete() { PersistentDiskConfiguration persistentConfiguration = PersistentDiskConfiguration.of(DISK_ID); comparePersistentDiskConfiguration( persistentConfiguration, AttachedDisk.AttachedDiskConfiguration.<PersistentDiskConfiguration>fromPb( persistentConfiguration.toPb())); ScratchDiskConfiguration scratchDiskConfiguration = ScratchDiskConfiguration.of(DISK_TYPE_ID); compareScratchDiskConfiguration( scratchDiskConfiguration, AttachedDisk.AttachedDiskConfiguration.<ScratchDiskConfiguration>fromPb( scratchDiskConfiguration.toPb())); CreateDiskConfiguration createDiskConfiguration = CreateDiskConfiguration.of(IMAGE_ID); compareCreateDiskConfiguration( createDiskConfiguration, AttachedDisk.AttachedDiskConfiguration.<CreateDiskConfiguration>fromPb( createDiskConfiguration.toPb())); }
@Test public void testAttachDiskNameWithOptions() throws Exception { initializeExpectedInstance(2); expect(compute.getOptions()).andReturn(mockOptions); AttachedDisk.PersistentDiskConfiguration configuration = AttachedDisk.PersistentDiskConfiguration.of(DISK_ID); Operation operation = new Operation.Builder(serviceMockReturnsOptions) .setOperationId(ZoneOperationId.of("project", "op")) .build(); expect(compute.attachDisk(INSTANCE_ID, "dev0", configuration, Compute.OperationOption.fields())) .andReturn(operation); replay(compute); initializeInstance(); assertSame( operation, instance.attachDisk("dev0", configuration, Compute.OperationOption.fields())); }
@Test public void testAttachDiskWithOptions() throws Exception { initializeExpectedInstance(2); expect(compute.getOptions()).andReturn(mockOptions); AttachedDisk.PersistentDiskConfiguration configuration = AttachedDisk.PersistentDiskConfiguration.of(DISK_ID); Operation operation = new Operation.Builder(serviceMockReturnsOptions) .setOperationId(ZoneOperationId.of("project", "op")) .build(); expect(compute.attachDisk(INSTANCE_ID, configuration, Compute.OperationOption.fields())) .andReturn(operation); replay(compute); initializeInstance(); assertSame(operation, instance.attachDisk(configuration, Compute.OperationOption.fields())); }
@Override Triple<InstanceId, String, PersistentDiskConfiguration> parse(String... args) throws Exception { String message; if (args.length == 4) { String zone = args[0]; String instance = args[1]; String deviceName = args[2]; String disk = args[3]; return Triple.of( InstanceId.of(zone, instance), deviceName, PersistentDiskConfiguration.of(DiskId.of(zone, disk))); } else if (args.length > 4) { message = "Too many arguments."; } else { message = "Missing required arguments."; } throw new IllegalArgumentException(message); }
@Test public void testAttachDiskNameIndex() throws Exception { initializeExpectedInstance(2); expect(compute.getOptions()).andReturn(mockOptions); AttachedDisk.PersistentDiskConfiguration configuration = AttachedDisk.PersistentDiskConfiguration.of(DISK_ID); Operation operation = new Operation.Builder(serviceMockReturnsOptions) .setOperationId(ZoneOperationId.of("project", "op")) .build(); expect(compute.attachDisk(INSTANCE_ID, "dev0", configuration, 1)).andReturn(operation); replay(compute); initializeInstance(); assertSame(operation, instance.attachDisk("dev0", configuration, 1)); }
@Test public void testAttachDiskName() throws Exception { initializeExpectedInstance(2); expect(compute.getOptions()).andReturn(mockOptions); AttachedDisk.PersistentDiskConfiguration configuration = AttachedDisk.PersistentDiskConfiguration.of(DISK_ID); Operation operation = new Operation.Builder(serviceMockReturnsOptions) .setOperationId(ZoneOperationId.of("project", "op")) .build(); expect(compute.attachDisk(INSTANCE_ID, "dev0", configuration)).andReturn(operation); replay(compute); initializeInstance(); assertSame(operation, instance.attachDisk("dev0", configuration)); }
@SuppressWarnings("unchecked") static <T extends AttachedDiskConfiguration> T fromPb( com.google.api.services.compute.model.AttachedDisk diskPb) { switch (Type.valueOf(diskPb.getType())) { case PERSISTENT: if (diskPb.getSource() == null) { return (T) CreateDiskConfiguration.fromPb(diskPb); } else { return (T) PersistentDiskConfiguration.fromPb(diskPb); } case SCRATCH: return (T) ScratchDiskConfiguration.fromPb(diskPb); default: // should be unreachable throw new IllegalArgumentException("Unrecognized attached disk type"); } } }