Java Attribute.setName方法代码示例

import com.amazonaws.services.simpledb.model.Attribute; //导入方法依赖的package包/类
@Override
public List<Booking> deleteBooking(Booking bookingToDelete, boolean isSquashServiceUserCall)
    throws Exception {

  if (!initialised) {
    throw new IllegalStateException("The booking manager has not been initialised");
  }

  getLifecycleManager().throwIfOperationInvalidForCurrentLifecycleState(false,
      isSquashServiceUserCall);

  logger.log("About to delete booking from database: " + bookingToDelete.toString());
  Attribute attribute = new Attribute();
  attribute.setName(getAttributeNameFromBooking(bookingToDelete));
  attribute.setValue(bookingToDelete.getName());
  getOptimisticPersister().delete(bookingToDelete.getDate(), attribute);

  logger.log("Deleted booking from database");

  return getVersionedBookings(bookingToDelete.getDate()).right;
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入方法依赖的package包/类
@Override
public void deleteRule(BookingRule bookingRuleToDelete, boolean isSquashServiceUserCall)
    throws Exception {

  if (!initialised) {
    throw new IllegalStateException("The rule manager has not been initialised");
  }

  lifecycleManager
      .throwIfOperationInvalidForCurrentLifecycleState(false, isSquashServiceUserCall);

  logger.log("About to delete booking rule from simpledb: " + bookingRuleToDelete.toString());

  String attributeName = getAttributeNameFromBookingRule(bookingRuleToDelete);
  String attributeValue = StringUtils.join(bookingRuleToDelete.getDatesToExclude(), ",");
  logger.log("Booking rule attribute name is: " + attributeName);
  logger.log("Booking rule attribute value is: " + attributeValue);
  Attribute attribute = new Attribute();
  attribute.setName(attributeName);
  attribute.setValue(attributeValue);
  optimisticPersister.delete(ruleItemName, attribute);

  logger.log("Deleted booking rule.");
  return;
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入方法依赖的package包/类
private void expectOptimisticPersisterToReturnVersionedAttributes(int expectedVersion,
    List<BookingRule> bookingRules, int numCalls) throws Exception {

  // Set up attributes to be returned from the database's booking rule item
  Set<Attribute> attributes = new HashSet<>();
  for (BookingRule bookingRule : bookingRules) {
    Attribute attribute = new Attribute();
    attribute.setName(getAttributeNameFromBookingRule(bookingRule));
    String[] datesToExclude = bookingRule.getDatesToExclude();
    attribute.setValue(StringUtils.join(datesToExclude, ","));
    attributes.add(attribute);
  }
  mockery.checking(new Expectations() {
    {
      exactly(numCalls).of(mockOptimisticPersister).get(with(equal(ruleItemName)));
      will(returnValue(new ImmutablePair<>(Optional.of(expectedVersion), attributes)));
    }
  });
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入方法依赖的package包/类
private void expectToDeleteRulesViaOptimisticPersister(List<BookingRule> rulesToDelete)
    throws Exception {

  // Set up attributes to be deleted from the database's booking rule item
  for (BookingRule ruleToDelete : rulesToDelete) {
    Attribute attribute = new Attribute();
    attribute.setName(getAttributeNameFromBookingRule(ruleToDelete));
    String[] datesToExclude = ruleToDelete.getDatesToExclude();
    attribute.setValue(StringUtils.join(datesToExclude, ","));

    mockery.checking(new Expectations() {
      {
        oneOf(mockOptimisticPersister).delete(with(equal(ruleItemName)), with(equal(attribute)));
      }
    });
  }
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入方法依赖的package包/类
@Before
public void beforeTest() {

  optimisticPersister = new TestOptimisticPersister();

  // Set up the mocks
  mockLogger = mockery.mock(LambdaLogger.class);
  mockery.checking(new Expectations() {
    {
      ignoring(mockLogger);
    }
  });
  mockSimpleDBClient = mockery.mock(AmazonSimpleDB.class);

  optimisticPersister.setSimpleDBClient(mockSimpleDBClient);

  // Set up some typical test attributes
  allAttributes = new HashSet<>();
  nonVersionAttributes = new HashSet<>();
  activeNonVersionAttributes = new HashSet<>();
  Attribute versionAttribute = new Attribute();
  versionAttribute.setName(versionAttributeName);
  versionAttribute.setValue(Integer.toString(testVersionNumber));
  Attribute activeAttribute = new Attribute();
  activeAttribute.setName("ActiveAttribute");
  activeAttribute.setValue("Active");
  Attribute inactiveAttribute = new Attribute();
  inactiveAttribute.setName("InactiveAttribute");
  inactiveAttribute.setValue("Inactive");
  allAttributes.add(versionAttribute);
  allAttributes.add(activeAttribute);
  allAttributes.add(inactiveAttribute);
  nonVersionAttributes.add(activeAttribute);
  nonVersionAttributes.add(inactiveAttribute);
  activeNonVersionAttributes.add(activeAttribute);
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入方法依赖的package包/类
@Test
public void testDeleteThrowsWhenOptimisticPersisterUninitialised() throws Exception {
  // ARRANGE
  thrown.expect(Exception.class);
  thrown.expectMessage("The optimistic persister has not been initialised");

  // ACT
  // Do not initialise the optimistic persister first - so delete should throw
  Attribute testAttribute = new Attribute();
  testAttribute.setName("Name");
  testAttribute.setValue("Value");
  optimisticPersister.delete(testItemName, testAttribute);
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入方法依赖的package包/类
private void doTestDeleteReturnsEarlyIfAttributeBeingDeletedDoesNotExist(
    Boolean versionNumberExists) throws Exception {

  // ARRANGE
  initialiseOptimisticPersister();

  // Configure database to return no attributes.
  GetAttributesRequest simpleDBRequest = new GetAttributesRequest(testSimpleDBDomainName,
      testItemName);
  simpleDBRequest.setConsistentRead(true);
  GetAttributesResult getAttributesResult = new GetAttributesResult();
  if (versionNumberExists) {
    // Ensure we return at least the version number attribute
    getAttributesResult.setAttributes(allAttributes);
  }
  mockery.checking(new Expectations() {
    {
      oneOf(mockSimpleDBClient).getAttributes(with(equal(simpleDBRequest)));
      will(returnValue(getAttributesResult));
    }
  });

  // Ensure we return early.
  mockery.checking(new Expectations() {
    {
      never(mockSimpleDBClient).deleteAttributes(with(anything()));
    }
  });

  // ACT
  Attribute attributeToDelete = new Attribute();
  attributeToDelete.setName("Name");
  attributeToDelete.setValue("Value");
  optimisticPersister.delete(testItemName, attributeToDelete);
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入方法依赖的package包/类
private void expectDeleteBookingToReturnUpdatedBookingsOrThrow(Booking bookingToDelete,
    Optional<List<Booking>> expectedBookingsAfterDelete, Optional<Exception> exceptionToThrow)
    throws Exception {

  String attributeName;
  attributeName = bookingToDelete.getCourt().toString() + "-"
      + bookingToDelete.getCourtSpan().toString() + "-" + bookingToDelete.getSlot().toString()
      + "-" + bookingToDelete.getSlotSpan().toString();

  Attribute attribute = new Attribute();
  attribute.setName(attributeName);
  attribute.setValue(bookingToDelete.getName());

  if (!exceptionToThrow.isPresent()) {
    mockery.checking(new Expectations() {
      {
        oneOf(mockOptimisticPersister).delete(with(equal(bookingToDelete.getDate())),
            with(equal(attribute)));
      }
    });

    // We expect call to getBookings after the delete
    Integer someArbitraryNumber = 42;
    expectOptimisticPersisterGetToReturnVersionedAttributesOrThrow(
        Optional.of(someArbitraryNumber), expectedBookingsAfterDelete.get(), Optional.empty());
  } else {
    mockery.checking(new Expectations() {
      {
        oneOf(mockOptimisticPersister).delete(with(equal(bookingToDelete.getDate())),
            with(equal(attribute)));
        will(throwException(exceptionToThrow.get()));
      }
    });
  }
  bookingManager.setOptimisticPersister(mockOptimisticPersister);
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入方法依赖的package包/类
@Test
public void testthrowIfOperationInvalidForCurrentLifecycleStateThrowsForEndUserCallsInRetiredStateWithoutUrl()
    throws Exception {
  // All end-user operations should not be allowed in RETIRED state. N.B.
  // System operations will still be allowed. This just adds check that if
  // we're retired but for some reason don't have a forwarding url that we
  // still throw. But we should never get to this state...

  // ARRANGE
  thrown.expect(Exception.class);
  thrown
      .expectMessage("Cannot access bookings or rules - there is an updated version of the booking service. Forwarding Url: UrlNotPresent");

  lifecycleManager.initialise(mockLogger);

  // Set up a defective retired lifecycle-state item - with missing url.
  Attribute retiredStateAttribute = new Attribute();
  retiredStateAttribute.setName("State");
  retiredStateAttribute.setValue("RETIRED");
  Set<Attribute> retiredAttributes = new HashSet<Attribute>();
  retiredAttributes.add(retiredStateAttribute);

  mockery.checking(new Expectations() {
    {
      exactly(1).of(mockOptimisticPersister).get(with(equal("LifecycleState")));
      will(returnValue(new ImmutablePair<Optional<Integer>, Set<Attribute>>(Optional.of(40),
          retiredAttributes)));
    }
  });

  // ACT
  // Should throw - as its an end-user operation when in RETIRED state.
  lifecycleManager.throwIfOperationInvalidForCurrentLifecycleState(true, true);
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入方法依赖的package包/类
@Before
public void beforeTest() {

  // Set up a retired lifecycle-state item - with arbitrary version number.
  Attribute retiredStateAttribute = new Attribute();
  retiredStateAttribute.setName("State");
  retiredStateAttribute.setValue("RETIRED");
  Attribute retiredUrlAttribute = new Attribute();
  retiredUrlAttribute.setName("Url");
  retiredUrlAttribute.setValue(exampleForwardingUrl);
  Set<Attribute> retiredAttributes = new HashSet<Attribute>();
  retiredAttributes.add(retiredStateAttribute);
  retiredAttributes.add(retiredUrlAttribute);
  exampleRetiredLifecycleItem = new ImmutablePair<Optional<Integer>, Set<Attribute>>(
      Optional.of(40), retiredAttributes);

  // Set up a readonly lifecycle-state item - with arbitrary version number.
  Attribute readonlyStateAttribute = new Attribute();
  readonlyStateAttribute.setName("State");
  readonlyStateAttribute.setValue("READONLY");
  Set<Attribute> readonlyAttributes = new HashSet<Attribute>();
  readonlyAttributes.add(readonlyStateAttribute);
  exampleReadonlyLifecycleItem = new ImmutablePair<Optional<Integer>, Set<Attribute>>(
      Optional.of(42), readonlyAttributes);

  // Set up an active lifecycle-state item - with arbitrary version number.
  Attribute activeStateAttribute = new Attribute();
  activeStateAttribute.setName("State");
  activeStateAttribute.setValue("ACTIVE");
  Set<Attribute> activeAttributes = new HashSet<Attribute>();
  activeAttributes.add(activeStateAttribute);
  exampleActiveLifecycleItem = new ImmutablePair<Optional<Integer>, Set<Attribute>>(
      Optional.of(43), activeAttributes);

  // Set up mock logger
  mockLogger = mockery.mock(LambdaLogger.class);
  mockery.checking(new Expectations() {
    {
      ignoring(mockLogger);
    }
  });
  mockOptimisticPersister = mockery.mock(IOptimisticPersister.class);

  // Set up the lifecycle manager
  lifecycleManager = new squash.booking.lambdas.core.LifecycleManagerTest.TestLifecycleManager();
  lifecycleManager.setOptimisticPersister(mockOptimisticPersister);
}