@Test
  public void testContinueOnSomeDbDirectoriesMissing() throws Exception {
    File targetDir1 = new File(System.getProperty("java.io.tmpdir"), UUID.randomUUID().toString());
    File targetDir2 = new File(System.getProperty("java.io.tmpdir"), UUID.randomUUID().toString());

    try {
      assertTrue(targetDir1.mkdirs());
      assertTrue(targetDir2.mkdirs());

      if (!targetDir1.setWritable(false, false)) {
        System.err.println(
            "Cannot execute 'testContinueOnSomeDbDirectoriesMissing' because cannot mark directory non-writable");
        return;
      }

      RocksDBStateBackend rocksDbBackend = new RocksDBStateBackend(TEMP_URI);
      rocksDbBackend.setDbStoragePaths(targetDir1.getAbsolutePath(), targetDir2.getAbsolutePath());

      try {
        rocksDbBackend.initializeForJob(getMockEnvironment(), "foobar", IntSerializer.INSTANCE);
      } catch (Exception e) {
        e.printStackTrace();
        fail("Backend initialization failed even though some paths were available");
      }
    } finally {
      //noinspection ResultOfMethodCallIgnored
      targetDir1.setWritable(true, false);
      FileUtils.deleteDirectory(targetDir1);
      FileUtils.deleteDirectory(targetDir2);
    }
  }
 @Test(groups = "slow")
 public void testSetDefaultPaymentMethod() throws Exception {
   final PaymentPluginApi api =
       getTestApi(paymentPluginApiOSGIServiceRegistration, BUNDLE_TEST_RESOURCE_PREFIX);
   api.setDefaultPaymentMethod(
       UUID.randomUUID(), UUID.randomUUID(), ImmutableList.<PluginProperty>of(), callContext);
 }
  @AfterReturning(
      pointcut =
          "execution(public String at.ac.tuwien.infosys.jcloudscale.server.JCloudScaleServer.createNewCloudObject(..))",
      returning = "ret")
  public void matchObjectCreated(JoinPoint jp, String ret) throws JCloudScaleException {

    try {
      ObjectCreatedEvent event = new ObjectCreatedEvent();
      initializeBaseEventProperties(event);
      UUID objectId = UUID.fromString(ret);
      event.setObjectId(objectId);
      JCloudScaleServer server = (JCloudScaleServer) jp.getThis();
      // XXX AbstractJCloudScaleServerRunner
      // UUID serverId = JCloudScaleServerRunner.getInstance().getId();
      UUID serverId = AbstractJCloudScaleServerRunner.getInstance().getId();
      event.setHostId(serverId);
      ClassLoader cl = server.getCloudObjectClassLoader(objectId);
      Class<?> theClazz = Class.forName((String) (jp.getArgs()[0]), true, cl);
      event.setObjectType(theClazz);
      getMqHelper().sendEvent(event);
      log.finer("Sent object created for object " + objectId.toString());
    } catch (Exception e) {
      e.printStackTrace();
      log.severe("Error while triggering ObjectCreatedEvent: " + e.getMessage());
    }
  }
  @Test
  public void shouldCountCarsWithFindCommand() throws Exception {
    String uniqueColorForTest = "color-shouldCountCarsWithFindCommand";
    Car exampleCar =
        CarBuilder.aCar()
            .withManufacturer(UUID.randomUUID().toString())
            .withColor(uniqueColorForTest)
            .build();
    saveNewCopiesOfCarToRepository(exampleCar, 10);

    Car secondExampleCar =
        CarBuilder.aCar()
            .withManufacturer(UUID.randomUUID().toString())
            .withColor(uniqueColorForTest)
            .build();
    saveNewCopiesOfCarToRepository(secondExampleCar, 5);

    //		Car searchByManufacturerExampleCar = new Car(null, 0, exampleCar.getManufacturer(), null);
    FindCommand<Car> findCommand = FindCommand.create(Car.class);
    findCommand.withSearchFilter("manufacturer", exampleCar.getManufacturer());
    long foundCars = carRepository.findTotalItemCount(findCommand);
    assertThat(foundCars).isEqualTo(10);

    FindCommand<Car> findCommand2 = FindCommand.create(Car.class);
    findCommand2.withSearchFilter("color", uniqueColorForTest);
    long foundCarsByColor = carRepository.findTotalItemCount(findCommand2);
    assertThat(foundCarsByColor).isEqualTo(15);

    FindCommand<Car> findCommand3 = FindCommand.create(Car.class);
    findCommand3.withSearchFilter("manufacturer", exampleCar.getManufacturer());
    findCommand3.withSearchFilter("color", uniqueColorForTest);
    long foundCarsByManufacturerAndColor = carRepository.findTotalItemCount(findCommand3);
    assertThat(foundCarsByManufacturerAndColor).isEqualTo(10);
  }
Exemplo n.º 5
0
  /** Make sure we can get a valid SAMLContextProvider. */
  @Test
  public void canGetContextProvider() {
    final SAMLProperties properties = Mockito.mock(SAMLProperties.class);

    Mockito.when(properties.getLoadBalancer()).thenReturn(null);

    SAMLContextProvider provider = this.config.contextProvider(properties);
    Assert.assertNotNull(provider);
    Assert.assertFalse(provider instanceof SAMLContextProviderLB);

    final SAMLProperties.LoadBalancer loadBalancer = new SAMLProperties.LoadBalancer();
    final String scheme = UUID.randomUUID().toString();
    loadBalancer.setScheme(scheme);
    final String serverName = UUID.randomUUID().toString();
    loadBalancer.setServerName(serverName);
    final int port = 443;
    loadBalancer.setServerPort(port);
    final String contextPath = UUID.randomUUID().toString();
    loadBalancer.setContextPath(contextPath);

    Mockito.when(properties.getLoadBalancer()).thenReturn(loadBalancer);
    provider = this.config.contextProvider(properties);
    Assert.assertNotNull(provider);
    Assert.assertTrue(provider instanceof SAMLContextProviderLB);
  }
Exemplo n.º 6
0
 @Override
 protected void execute(CommandSender cs, String... args) {
   PlotBuild plotbuild = checkPlotBuild((Player) cs, 1, args);
   if (plotbuild == null) {
     return;
   }
   if (!hasPermissionsForPlotBuild((Player) cs, plotbuild)) {
     return;
   }
   OfflinePlayer removedStaff = BukkitUtil.matchPlayer(args[0]);
   if (removedStaff == null) {
     removedStaff = Bukkit.getOfflinePlayer(args[0]);
   }
   if (removedStaff.getLastPlayed() == 0) {
     sendPlayerNotFoundMessage(cs);
     return;
   }
   if (!plotbuild.isStaff(removedStaff)) {
     sendNotStaffMessage(cs, removedStaff, plotbuild.getName());
     return;
   }
   plotbuild.removeStaff(removedStaff);
   sendRemoveStaffMessage(cs, removedStaff.getName(), plotbuild.getName());
   if (removedStaff.getPlayer() != cs) {
     sendRemovedStaffPlayerMessage(cs, removedStaff, plotbuild.getName());
   }
   for (UUID staff : plotbuild.getOfflineStaffList()) {
     if (!staff.equals(((Player) cs).getUniqueId()) && !staff.equals(removedStaff.getUniqueId())) {
       sendOtherStaffMessage(
           cs, Bukkit.getOfflinePlayer(staff), removedStaff, plotbuild.getName());
     }
   }
   plotbuild.log(((Player) cs).getName() + " removed " + removedStaff.getName() + " from staff.");
   PluginData.saveData();
 }
  @Test
  public void shouldFindCarsByExample() throws Exception {
    String uniqueColor = "unique-color-" + UUID.randomUUID().toString();
    Car exampleCar =
        CarBuilder.aCar()
            .withManufacturer(UUID.randomUUID().toString())
            .withColor(uniqueColor)
            .build();
    saveNewCopiesOfCarToRepository(exampleCar, 10);

    Car secondExampleCar =
        CarBuilder.aCar()
            .withManufacturer(UUID.randomUUID().toString())
            .withColor(uniqueColor)
            .build();
    saveNewCopiesOfCarToRepository(secondExampleCar, 5);

    Car searchByManufacturerExampleCar = new Car(null, 0, exampleCar.getManufacturer(), null);
    List<Car> foundCars = carRepository.findByExample(searchByManufacturerExampleCar);
    assertThat(foundCars).isNotNull().hasSize(10);

    Car searchByColorExampleCar = new Car(null, 0, null, uniqueColor);
    List<Car> foundCarsByColor = carRepository.findByExample(searchByColorExampleCar);
    assertThat(foundCarsByColor).isNotNull().hasSize(15);

    Car searchByManufacturerAndColorExampleCar =
        new Car(null, 0, exampleCar.getManufacturer(), uniqueColor);
    List<Car> foundCarsByManufacturerAndColor =
        carRepository.findByExample(searchByManufacturerAndColorExampleCar);
    assertThat(foundCarsByManufacturerAndColor).isNotNull().hasSize(10);
  }
  @Test
  public void initiate() throws Exception {
    Person bob = new Person(UUID.randomUUID());
    String sessionId = (new Date()).toString();
    securityService.setCurrent(bob);

    UUID selfHelpGuideId = UUID.randomUUID();

    SelfHelpGuide selfHelpGuide = new SelfHelpGuide();
    SelfHelpGuideResponse selfHelpGuideResponse = new SelfHelpGuideResponse();

    expect(selfHelpGuideService.get(selfHelpGuideId)).andReturn(selfHelpGuide);

    expect(service.initiateSelfHelpGuideResponse(selfHelpGuide, bob, sessionId))
        .andReturn(selfHelpGuideResponse);

    replay(service);
    replay(selfHelpGuideService);

    String response = controller.initiate(selfHelpGuideId);

    verify(service);
    verify(selfHelpGuideService);
    assertEquals(selfHelpGuideResponse.toString(), response);
  }
  @Test
  public void answer() throws ObjectNotFoundException {
    UUID selfHelpGuideResponseId = UUID.randomUUID();
    UUID selfHelpGuideQuestionId = UUID.randomUUID();
    Boolean answerResponse = true;
    SelfHelpGuideResponse selfHelpGuideResponse = new SelfHelpGuideResponse();
    SelfHelpGuideQuestion selfHelpGuideQuestion = new SelfHelpGuideQuestion();

    expect(service.get(selfHelpGuideResponseId)).andReturn(selfHelpGuideResponse);
    expect(selfHelpGuideQuestionService.get(selfHelpGuideQuestionId))
        .andReturn(selfHelpGuideQuestion);
    expect(
            service.answerSelfHelpGuideQuestion(
                selfHelpGuideResponse, selfHelpGuideQuestion, answerResponse))
        .andReturn(false);

    replay(service);
    replay(selfHelpGuideQuestionService);

    try {
      Boolean response =
          controller.answer(selfHelpGuideResponseId, selfHelpGuideQuestionId, answerResponse);

      verify(service);
      verify(selfHelpGuideQuestionService);
      assertFalse(response);
    } catch (Exception e) {
      fail("controller error");
    }
  }
 public static void addCryptoInputParcel(
     Context context, Intent data, CryptoInputParcel inputParcel) {
   UUID mTicket = addCryptoInputParcel(context, inputParcel);
   // And write out the UUID most and least significant bits.
   data.putExtra(OpenPgpApi.EXTRA_CALL_UUID1, mTicket.getMostSignificantBits());
   data.putExtra(OpenPgpApi.EXTRA_CALL_UUID2, mTicket.getLeastSignificantBits());
 }
  @Test
  public void testCreateZoneWithNonUniqueSubdomain() {
    IdentityZone idZone1 = new IdentityZone();
    String id1 = UUID.randomUUID().toString();
    idZone1.setId(id1);
    idZone1.setSubdomain(id1 + "non-unique");
    idZone1.setName("testCreateZone() " + id1);
    ResponseEntity<Void> response1 =
        client.exchange(
            serverRunning.getUrl("/identity-zones"),
            HttpMethod.POST,
            new HttpEntity<>(idZone1),
            new ParameterizedTypeReference<Void>() {},
            id1);
    assertEquals(HttpStatus.CREATED, response1.getStatusCode());

    IdentityZone idZone2 = new IdentityZone();
    String id2 = UUID.randomUUID().toString();
    idZone2.setId(id2);
    idZone2.setSubdomain(id1 + "non-unique");
    idZone2.setName("testCreateZone() " + id2);
    ResponseEntity<Map<String, String>> response2 =
        client.exchange(
            serverRunning.getUrl("/identity-zones"),
            HttpMethod.POST,
            new HttpEntity<>(idZone2),
            new ParameterizedTypeReference<Map<String, String>>() {},
            id2);
    assertEquals(HttpStatus.CONFLICT, response2.getStatusCode());
    Assert.assertTrue(
        response2.getBody().get("error_description").toLowerCase().contains("subdomain"));
  }
    @Test
    public void testUpdateState() throws Throwable {
      assertThat(vm.getState(), is(not(VmState.ERROR)));
      vmDcpBackend.updateState(vm, VmState.ERROR);
      assertThat(vm.getState(), is(VmState.ERROR));
      vm = vmDcpBackend.findById(vmId);
      assertThat(vm.getState(), is(VmState.ERROR));

      String agent = UUID.randomUUID().toString();
      String agentIp = UUID.randomUUID().toString();
      String datastoreId = UUID.randomUUID().toString();
      String datastoreName = UUID.randomUUID().toString();

      vmDcpBackend.updateState(vm, VmState.STARTED, agent, agentIp, datastoreId, datastoreName);
      assertThat(vm.getState(), is(VmState.STARTED));
      assertThat(vm.getAgent(), is(agent));
      assertThat(vm.getHost(), is(agentIp));
      assertThat(vm.getDatastore(), is(datastoreId));
      assertThat(vm.getDatastoreName(), is(datastoreName));
      vm = vmDcpBackend.findById(vmId);
      assertThat(vm.getState(), is(VmState.STARTED));
      assertThat(vm.getAgent(), is(agent));
      assertThat(vm.getHost(), is(agentIp));
      assertThat(vm.getDatastore(), is(datastoreId));
      assertThat(vm.getDatastoreName(), is(datastoreName));
    }
  public void setUpMockitoRules() throws Exception {

    when(mockPluginDatabaseSystem.openDatabase(pluginId, pluginId.toString()))
        .thenReturn(mockDatabase);

    when(mockExtraUserActorDatabaseFactory.createDatabase(pluginId, pluginId.toString()))
        .thenReturn(mockDatabase);

    when(mockDatabase.getTable(ExtraUserActorDatabaseConstants.EXTRA_USER_TABLE_NAME))
        .thenReturn(mockTable);
    when(mockTable.getRecords()).thenReturn(mockRecords);
    when(mockRecords.get(anyInt())).thenReturn(mockTableRecord);
    when(mockPluginFileSystem.getBinaryFile(
            any(UUID.class),
            anyString(),
            anyString(),
            any(FilePrivacy.class),
            any(FileLifeSpan.class)))
        .thenReturn(mockBinaryFile);

    when(mockPluginFileSystem.getTextFile(
            any(UUID.class),
            anyString(),
            anyString(),
            any(FilePrivacy.class),
            any(FileLifeSpan.class)))
        .thenReturn(mockFile);

    when(mockBinaryFile.getContent()).thenReturn(new byte[100]);
  }
  @Test(groups = "slow")
  public void testGetPaymentInfo() throws Exception {
    final PaymentPluginApi api =
        getTestApi(paymentPluginApiOSGIServiceRegistration, BUNDLE_TEST_RESOURCE_PREFIX);

    final DateTime beforeCall = new DateTime().toDateTime(DateTimeZone.UTC).minusSeconds(1);
    final PaymentTransactionInfoPlugin res =
        api.getPaymentInfo(
                UUID.randomUUID(),
                UUID.randomUUID(),
                ImmutableList.<PluginProperty>of(),
                callContext)
            .get(0);
    final DateTime afterCall = new DateTime().toDateTime(DateTimeZone.UTC).plusSeconds(1);

    Assert.assertTrue(res.getAmount().compareTo(BigDecimal.ZERO) == 0);
    Assert.assertTrue(res.getCreatedDate().compareTo(beforeCall) >= 0);
    Assert.assertTrue(res.getCreatedDate().compareTo(afterCall) <= 0);

    Assert.assertTrue(res.getEffectiveDate().compareTo(beforeCall) >= 0);
    Assert.assertTrue(res.getEffectiveDate().compareTo(afterCall) <= 0);

    assertEquals(res.getGatewayError(), "gateway_error");
    assertEquals(res.getGatewayErrorCode(), "gateway_error_code");

    assertEquals(res.getStatus(), PaymentPluginStatus.PROCESSED);
  }
Exemplo n.º 15
0
  private Account createTestAccount(final int billCycleDay, final String phone) {
    final String thisKey = "test" + UUID.randomUUID().toString();
    final String lastName = UUID.randomUUID().toString();
    final String thisEmail = "*****@*****.**" + " " + UUID.randomUUID();
    final String firstName = "Bob";
    final String name = firstName + " " + lastName;
    final String locale = "EN-US";
    final DateTimeZone timeZone = DateTimeZone.forID("America/Los_Angeles");
    final int firstNameLength = firstName.length();

    return new DefaultAccount(
        UUID.randomUUID(),
        thisKey,
        thisEmail,
        name,
        firstNameLength,
        Currency.USD,
        new DefaultBillCycleDay(billCycleDay, billCycleDay),
        UUID.randomUUID(),
        timeZone,
        locale,
        null,
        null,
        null,
        null,
        null,
        null,
        null, // add null address fields
        phone,
        false,
        false);
  }
Exemplo n.º 16
0
 /**
  * Serialize an object into a given byte buffer.
  *
  * @param o The object to serialize.
  * @param b The bytebuf to serialize it into.
  */
 @Override
 public void serialize(Object o, ByteBuf b) {
   String className = o == null ? "null" : o.getClass().getName();
   if (className.contains("$ByteBuddy$")) {
     String SMRClass = className.split("\\$")[0];
     className = "CorfuObject";
     byte[] classNameBytes = className.getBytes();
     b.writeShort(classNameBytes.length);
     b.writeBytes(classNameBytes);
     byte[] SMRClassNameBytes = SMRClass.getBytes();
     b.writeShort(SMRClassNameBytes.length);
     b.writeBytes(SMRClassNameBytes);
     UUID id = ((ICorfuObject) o).getStreamID();
     log.trace("Serializing a CorfuObject of type {} as a stream pointer to {}", SMRClass, id);
     b.writeLong(id.getMostSignificantBits());
     b.writeLong(id.getLeastSignificantBits());
   } else {
     byte[] classNameBytes = className.getBytes();
     b.writeShort(classNameBytes.length);
     b.writeBytes(classNameBytes);
     if (o == null) {
       return;
     }
     try (ByteBufOutputStream bbos = new ByteBufOutputStream(b)) {
       try (OutputStreamWriter osw = new OutputStreamWriter(bbos)) {
         gson.toJson(o, o.getClass(), osw);
       }
     } catch (IOException ie) {
       log.error("Exception during serialization!", ie);
     }
   }
 }
Exemplo n.º 17
0
  public static String generateUUIDs(int howMany) {

    StringBuilder builder = new StringBuilder();

    // Append normal UUIDs:
    for (int count = 0; count < howMany; count++) {
      builder.append(UUID.randomUUID().toString()).append("\n");
    }

    builder.append("\n");

    // Append uppercase UUIDs:
    for (int count = 0; count < howMany; count++) {
      builder.append(UUID.randomUUID().toString().toUpperCase()).append("\n");
    }

    builder.append("\n");

    // Append uppercase w/ dashes removed:
    for (int count = 0; count < howMany; count++) {
      builder.append(UUID.randomUUID().toString().toUpperCase().replace("-", "")).append("\n");
    }

    return builder.toString();
  }
Exemplo n.º 18
0
 @Override
 public boolean onCommand(CommandSender sender, Command cmd, String tag, String[] args) {
   if (tag.equalsIgnoreCase("cancelauto")) {
     if (sender.hasPermission(Permission.AUTO_CANCEL)) {
       if (args.length == 0) {
         sender.sendMessage(ChatColor.YELLOW + "/cancelauto <player>");
         return true;
       } else {
         if (auto.contains(args[0].trim())) {
           auto.remove(args[0].trim());
           sender.sendMessage(
               ChatColor.YELLOW + "Autoban for " + args[0].trim() + " has been cancelled!");
           for (Player online : Bukkit.getOnlinePlayers()) {
             if (online != sender) {
               if (online.hasPermission(Permission.AUTO)) {
                 online.sendMessage(
                     ChatColor.GOLD + sender.getName() + " removed " + args[0] + "'s autoban!");
               }
             }
           }
         } else if (time.containsKey(UUID.fromString(args[0].trim()))) {
           time.put(UUID.fromString(args[0].trim()), 0);
           sender.sendMessage(ChatColor.YELLOW + "Autoban cancelled!");
         } else {
           sender.sendMessage(
               ChatColor.YELLOW + "This player does not have an autoban scheduled!");
         }
       }
     } else {
       sender.sendMessage(ChatColor.WHITE + "Unknown Command! Type \"/help\" for help.");
       return true;
     }
   }
   return true;
 }
Exemplo n.º 19
0
 @Override
 public OutputStream getOutputStream(Blob blob) throws BlobException {
   UUID uuid = UUID.randomUUID();
   byte[] blobKey = Bytes.toBytes(uuid.getMostSignificantBits());
   blobKey = Bytes.add(blobKey, Bytes.toBytes(uuid.getLeastSignificantBits()));
   return new HBaseBlobOutputStream(table, blobKey, blob);
 }
Exemplo n.º 20
0
  public DeviceUuidFactory(Context context) {

    if (uuid == null) {
      synchronized (DeviceUuidFactory.class) {
        if (uuid == null) {
          final SharedPreferences prefs =
              context.getSharedPreferences(PREFS_FILE, Context.MODE_PRIVATE);
          final String id = prefs.getString(PREFS_DEVICE_ID, null);

          if (id != null) {
            // Use the ids previously computed and stored in the
            // prefs file
            uuid = UUID.fromString(id);

          } else {

            UUID newId = UUID.randomUUID();
            uuid = newId;

            // Write the value out to the prefs file
            prefs.edit().putString(PREFS_DEVICE_ID, newId.toString()).commit();
          }
        }
      }
    }
  }
  @Test
  public void shouldFindCarsWithFindCommandAndNamedQuery() throws Exception {
    //		String uniqueColorForTest = "black-and-pink-with-ruby-named-query";
    Car exampleCar =
        CarBuilder.aCar().withManufacturer(UUID.randomUUID().toString()).withYear(2000).build();
    saveNewCopiesOfCarToRepository(exampleCar, 10);

    Car secondExampleCar =
        CarBuilder.aCar().withManufacturer(UUID.randomUUID().toString()).withYear(2005).build();
    saveNewCopiesOfCarToRepository(secondExampleCar, 5);

    //		Car searchByManufacturerExampleCar = new Car(null, 0, exampleCar.getManufacturer(), null);
    FindCommand<Car> findCommand = FindCommand.create(Car.class);
    findCommand.withSearchFilter("year", "2000").withNamedQuery("Car.findGreaterThanYear");
    List<Car> foundCars = carRepository.findItemsWith(findCommand);
    assertThat(foundCars).isNotNull().hasSize(10);

    FindCommand<Car> findCommand2 =
        FindCommand.create(Car.class)
            .withSearchFilter("year", "2005")
            .withNamedQuery("Car.findGreaterThanYear");

    List<Car> foundCarsByColor = carRepository.findItemsWith(findCommand2);
    assertThat(foundCarsByColor).isNotNull().hasSize(5);

    /*FindCommand<Car> findCommand3 = FindCommand.create(Car.class)
    		.withNamedQuery("Car.findGreaterThanYear");
    findCommand3.withSearchFilter("manufacturer", exampleCar.getManufacturer());
    findCommand3.withSearchFilter("color", uniqueColorForTest);
    List<Car> foundCarsByManufacturerAndColor = carRepository.findItemsWith(findCommand3);
    assertThat(foundCarsByManufacturerAndColor).isNotNull().hasSize(10);*/
  }
Exemplo n.º 22
0
 public String uuidToBase64(String str) {
   UUID uuid = UUID.fromString(str);
   ByteBuffer bb = ByteBuffer.wrap(new byte[16]);
   bb.putLong(uuid.getMostSignificantBits());
   bb.putLong(uuid.getLeastSignificantBits());
   return Base64.encodeBase64URLSafeString(bb.array());
 }
Exemplo n.º 23
0
  /** This test tests that complete packet is build correctly */
  public static void PacketBuilderTest() throws IOException, JdpException {

    /* Complete packet test */
    {
      JdpJmxPacket p1 = new JdpJmxPacket(UUID.randomUUID(), "fake://unit-test");
      p1.setMainClass("FakeUnitTest");
      p1.setInstanceName("Fake");
      byte[] b = p1.getPacketData();

      JdpJmxPacket p2 = new JdpJmxPacket(b);
      JdpDoSomething.printJdpPacket(p1);
      JdpDoSomething.compaireJdpPacketEx(p1, p2);
    }

    /*Missed field packet test*/
    {
      JdpJmxPacket p1 = new JdpJmxPacket(UUID.randomUUID(), "fake://unit-test");
      p1.setMainClass("FakeUnitTest");
      p1.setInstanceName(null);
      byte[] b = p1.getPacketData();

      JdpJmxPacket p2 = new JdpJmxPacket(b);
      JdpDoSomething.printJdpPacket(p1);
      JdpDoSomething.compaireJdpPacketEx(p1, p2);
    }

    System.out.println("OK: Test passed");
  }
Exemplo n.º 24
0
  /** Get a list of all the people that ignorer is ignoring */
  public static ArrayDeque<UUIDName> get_ignoring(UUID ignorer) {
    ArrayDeque<UUIDName> ret = null;
    try {
      String query = "SELECT * FROM ignores WHERE " + "ignorer = ?;";
      PreparedStatement st = conn.prepareStatement(query);
      st.setString(1, ignorer.toString());

      ResultSet rs = st.executeQuery();
      ret = new ArrayDeque<UUIDName>();
      while (rs.next()) {
        UUID uuid = UUID.fromString(rs.getString("ignored"));
        String name = rs.getString("ignoredname");

        UUIDName tmp = new UUIDName(uuid, name);
        ret.add(tmp);
      }

      rs.close();
      st.close();

    } catch (Exception e) {
      Ignore.instance.getLogger().warning(e.getMessage());
    }

    return ret;
  }
Exemplo n.º 25
0
  private SAMLProperties setupForKeyManager() {
    final ResourceLoader resourceLoader = Mockito.mock(ResourceLoader.class);
    this.config.setResourceLoader(resourceLoader);
    final Resource storeFile = Mockito.mock(Resource.class);

    final SAMLProperties properties = Mockito.mock(SAMLProperties.class);
    this.config.setSamlProperties(properties);

    final String keyStorePassword = UUID.randomUUID().toString();
    final String keyStoreName = UUID.randomUUID().toString() + ".jks";
    final String defaultKeyName = UUID.randomUUID().toString();
    final String defaultKeyPassword = UUID.randomUUID().toString();

    final SAMLProperties.Keystore keyStore = Mockito.mock(SAMLProperties.Keystore.class);
    final SAMLProperties.Keystore.DefaultKey defaultKey =
        Mockito.mock(SAMLProperties.Keystore.DefaultKey.class);
    Mockito.when(properties.getKeystore()).thenReturn(keyStore);
    Mockito.when(keyStore.getName()).thenReturn(keyStoreName);
    Mockito.when(keyStore.getPassword()).thenReturn(keyStorePassword);
    Mockito.when(keyStore.getDefaultKey()).thenReturn(defaultKey);
    Mockito.when(defaultKey.getName()).thenReturn(defaultKeyName);
    Mockito.when(defaultKey.getPassword()).thenReturn(defaultKeyPassword);
    Mockito.when(resourceLoader.getResource(Mockito.eq("classpath:" + keyStoreName)))
        .thenReturn(storeFile);

    return properties;
  }
Exemplo n.º 26
0
  @Test(groups = "slow")
  public void testShouldBeAbleToHandleOtherBCDClass() throws Exception {
    final Account account = createTestAccount();
    accountDao.create(account, internalCallContext);

    final MutableAccountData otherAccount = account.toMutableAccountData();
    otherAccount.setAddress1(UUID.randomUUID().toString());
    otherAccount.setEmail(UUID.randomUUID().toString());
    // Same BCD, but not .equals method
    otherAccount.setBillCycleDay(
        new BillCycleDay() {
          @Override
          public int getDayOfMonthUTC() {
            return account.getBillCycleDay().getDayOfMonthUTC();
          }

          @Override
          public int getDayOfMonthLocal() {
            return account.getBillCycleDay().getDayOfMonthLocal();
          }
        });

    final DefaultAccount newAccount = new DefaultAccount(account.getId(), otherAccount);
    accountDao.update(newAccount, internalCallContext);

    final Account newFetchedAccount = accountDao.getById(account.getId(), internalCallContext);
    Assert.assertEquals(newFetchedAccount.getAddress1(), newAccount.getAddress1());
    Assert.assertEquals(newFetchedAccount.getEmail(), newAccount.getEmail());
    // Same BCD
    Assert.assertEquals(newFetchedAccount.getBillCycleDay(), account.getBillCycleDay());
  }
  @Override
  public void read(DataInput in) throws IOException {
    try {
      long msb = in.readLong();
      long lsb = in.readLong();
      this.token = new UUID(msb, lsb);
    } catch (Exception e) {
      throw new UnknownStoreVersionException(e);
    }

    if (!token.equals(JobSchedulerStoreImpl.SCHEDULER_STORE_TOKEN)) {
      throw new UnknownStoreVersionException(token.toString());
    }
    this.version = in.readInt();
    if (in.readBoolean()) {
      setLastUpdateLocation(LocationMarshaller.INSTANCE.readPayload(in));
    } else {
      setLastUpdateLocation(null);
    }
    this.storedSchedulers =
        new BTreeIndex<String, JobSchedulerImpl>(store.getPageFile(), in.readLong());
    this.storedSchedulers.setKeyMarshaller(StringMarshaller.INSTANCE);
    this.storedSchedulers.setValueMarshaller(new JobSchedulerMarshaller(this.store));
    this.journalRC = new BTreeIndex<Integer, Integer>(store.getPageFile(), in.readLong());
    this.journalRC.setKeyMarshaller(IntegerMarshaller.INSTANCE);
    this.journalRC.setValueMarshaller(IntegerMarshaller.INSTANCE);
    this.removeLocationTracker =
        new BTreeIndex<Integer, List<Integer>>(store.getPageFile(), in.readLong());
    this.removeLocationTracker.setKeyMarshaller(IntegerMarshaller.INSTANCE);
    this.removeLocationTracker.setValueMarshaller(new IntegerListMarshaller());

    LOG.info("Scheduler Store version {} loaded", this.version);
  }
Exemplo n.º 28
0
  private void verifyAccountEmailAuditAndHistoryCount(
      final UUID accountId, final int expectedCount) {
    final Handle handle = dbi.open();

    // verify audit
    StringBuilder sb = new StringBuilder();
    sb.append("select * from audit_log a ");
    sb.append("inner join account_email_history aeh on a.record_id = aeh.history_record_id ");
    sb.append("where a.table_name = 'account_email_history' ");
    sb.append(String.format("and aeh.account_id='%s'", accountId.toString()));
    List<Map<String, Object>> result = handle.select(sb.toString());
    assertEquals(result.size(), expectedCount);

    // ***** NOT IDEAL
    // ... but this works after the email record has been deleted; will likely fail when multiple
    // emails exist for the same account
    // verify history table
    sb = new StringBuilder();
    sb.append("select * from account_email_history aeh ");
    sb.append(String.format("where aeh.account_id='%s'", accountId.toString()));
    result = handle.select(sb.toString());
    assertEquals(result.size(), expectedCount);

    handle.close();
  }
Exemplo n.º 29
0
  @Test
  public void testCreateRefFromUri() throws BadRequestException {
    final ParentListRef comptes_expected =
        ParentListRefImpl.create( //
            Mediatheque.ref(UUID.fromString("448028fd-fce5-45a5-8ef4-2b591800a7e2")) //
            ,
            Compte.mCompte //
            ,
            "comptes") //
        ;
    final ParentListRef<Mediatheque.Ref, Compte> comptes_result =
        Mediatheque.mMediatheque.comptes.parse(
            "mediatheque/448028fd-fce5-45a5-8ef4-2b591800a7e2/comptes");
    assertEquals(comptes_expected, comptes_result);
    // ListRef result1 = Mediatheque.mMediatheque.comptes_ref();

    final UUID idMediatheque = UUID.randomUUID();
    final Mediatheque.Ref mediatheque_expected = Mediatheque.ref(idMediatheque);
    final Mediatheque.Ref mediatheque_result =
        Mediatheque.mMediatheque.createRefFromUri("mediatheque/" + idMediatheque);
    assertEquals(mediatheque_expected, mediatheque_result);

    final UUID idIndividu = UUID.randomUUID();
    final Individu.Ref individu_expected = Individu.ref(idIndividu);
    final Individu.Ref individu_result =
        Individu.mIndividu.createRefFromUri("individu/" + idIndividu);
    assertEquals(individu_expected, individu_result);

    final Compte.Ref compte_expected = Compte.ref(mediatheque_expected, individu_expected);
    final Compte.Ref compte_result =
        Compte.mCompte.createRefFromUri(
            "mediatheque/" + idMediatheque + "/comptes/individu/" + idIndividu);
    assertEquals(compte_expected, compte_result);
  }
  /**
   * Tests that a job is properly canceled in the event of a leader change. However, this time only
   * the TMs are notified about the changing leader. This should be enough to cancel the currently
   * running job, though.
   */
  @Test
  public void testStateCleanupAfterListenerNotification() throws Exception {
    UUID leaderSessionID = UUID.randomUUID();
    UUID newLeaderSessionID = UUID.randomUUID();

    cluster.grantLeadership(0, leaderSessionID);
    cluster.notifyRetrievalListeners(0, leaderSessionID);

    cluster.waitForTaskManagersToBeRegistered();

    // submit blocking job
    cluster.submitJobDetached(job);

    ActorGateway jm = cluster.getLeaderGateway(timeout);

    Future<Object> wait =
        jm.ask(new WaitForAllVerticesToBeRunningOrFinished(job.getJobID()), timeout);

    Await.ready(wait, timeout);

    Future<Object> jobRemoval = jm.ask(new NotifyWhenJobRemoved(job.getJobID()), timeout);

    // notify listeners (TMs) about the leader change
    cluster.notifyRetrievalListeners(1, newLeaderSessionID);

    Await.ready(jobRemoval, timeout);
  }