com.hazelcast.map.listener.MapListener Java Examples

@Test
@SuppressWarnings("unchecked")
void saveWithSaveModeAlways() {
	verify(this.sessions).addEntryListener(any(MapListener.class), anyBoolean());
	this.repository.setSaveMode(SaveMode.ALWAYS);
	MapSession delegate = new MapSession();
	delegate.setAttribute("attribute1", "value1");
	delegate.setAttribute("attribute2", "value2");
	delegate.setAttribute("attribute3", "value3");
	HazelcastSession session = this.repository.new HazelcastSession(delegate, false);
	session.getAttribute("attribute2");
	session.setAttribute("attribute3", "value4");
	this.repository.save(session);
	ArgumentCaptor<SessionUpdateEntryProcessor> captor = ArgumentCaptor.forClass(SessionUpdateEntryProcessor.class);
	verify(this.sessions).executeOnKey(eq(session.getId()), captor.capture());
	assertThat((Map<String, Object>) ReflectionTestUtils.getField(captor.getValue(), "delta")).hasSize(3);
	verifyZeroInteractions(this.sessions);
}
 

@Test
@SuppressWarnings("unchecked")
void saveWithSaveModeOnGetAttribute() {
	verify(this.sessions).addEntryListener(any(MapListener.class), anyBoolean());
	this.repository.setSaveMode(SaveMode.ON_GET_ATTRIBUTE);
	MapSession delegate = new MapSession();
	delegate.setAttribute("attribute1", "value1");
	delegate.setAttribute("attribute2", "value2");
	delegate.setAttribute("attribute3", "value3");
	HazelcastSession session = this.repository.new HazelcastSession(delegate, false);
	session.getAttribute("attribute2");
	session.setAttribute("attribute3", "value4");
	this.repository.save(session);
	ArgumentCaptor<SessionUpdateEntryProcessor> captor = ArgumentCaptor.forClass(SessionUpdateEntryProcessor.class);
	verify(this.sessions).executeOnKey(eq(session.getId()), captor.capture());
	assertThat((Map<String, Object>) ReflectionTestUtils.getField(captor.getValue(), "delta")).hasSize(2);
	verifyZeroInteractions(this.sessions);
}
 

@Test
@SuppressWarnings("unchecked")
void saveWithSaveModeOnSetAttribute() {
	verify(this.sessions).addEntryListener(any(MapListener.class), anyBoolean());
	this.repository.setSaveMode(SaveMode.ON_SET_ATTRIBUTE);
	MapSession delegate = new MapSession();
	delegate.setAttribute("attribute1", "value1");
	delegate.setAttribute("attribute2", "value2");
	delegate.setAttribute("attribute3", "value3");
	HazelcastSession session = this.repository.new HazelcastSession(delegate, false);
	session.getAttribute("attribute2");
	session.setAttribute("attribute3", "value4");
	this.repository.save(session);
	ArgumentCaptor<SessionUpdateEntryProcessor> captor = ArgumentCaptor.forClass(SessionUpdateEntryProcessor.class);
	verify(this.sessions).executeOnKey(eq(session.getId()), captor.capture());
	assertThat((Map<String, Object>) ReflectionTestUtils.getField(captor.getValue(), "delta")).hasSize(1);
	verifyZeroInteractions(this.sessions);
}
 

public HazelcastEventStore(int maxLogSizePerAggregate, IMap<InstanceId, List<InstanceEvent>> eventLog) {
    super(maxLogSizePerAggregate, eventLog);

    eventLog.addEntryListener((MapListener) new EntryAdapter<InstanceId, List<InstanceEvent>>() {
        @Override
        public void entryUpdated(EntryEvent<InstanceId, List<InstanceEvent>> event) {
            log.debug("Updated {}", event);
            long lastKnownVersion = getLastVersion(event.getOldValue());
            List<InstanceEvent> newEvents = event.getValue()
                                                 .stream()
                                                 .filter(e -> e.getVersion() > lastKnownVersion)
                                                 .collect(Collectors.toList());
            HazelcastEventStore.this.publish(newEvents);
        }
    }, true);
}
 

@Test
void saveUpdatedMaxInactiveIntervalInSecondsFlushModeImmediate() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	this.repository.setFlushMode(FlushMode.IMMEDIATE);

	HazelcastSession session = this.repository.createSession();
	String sessionId = session.getId();
	session.setMaxInactiveInterval(Duration.ofSeconds(1));
	verify(this.sessions, times(1)).set(eq(sessionId), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));
	verify(this.sessions).setTtl(eq(sessionId), anyLong(), any());
	verify(this.sessions, times(1)).executeOnKey(eq(sessionId), any(EntryProcessor.class));

	this.repository.save(session);
	verifyZeroInteractions(this.sessions);
}
 

@Test
void saveUpdatedMaxInactiveIntervalInSecondsFlushModeOnSave() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	HazelcastSession session = this.repository.createSession();
	session.setMaxInactiveInterval(Duration.ofSeconds(1));
	verifyZeroInteractions(this.sessions);

	this.repository.save(session);
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));
	verifyZeroInteractions(this.sessions);
}
 

public HazelcastEventStore(int maxLogSizePerAggregate, IMap<InstanceId, List<InstanceEvent>> eventLog) {
	super(maxLogSizePerAggregate, eventLog);

	eventLog.addEntryListener((MapListener) new EntryAdapter<InstanceId, List<InstanceEvent>>() {
		@Override
		public void entryUpdated(EntryEvent<InstanceId, List<InstanceEvent>> event) {
			log.debug("Updated {}", event);
			long lastKnownVersion = getLastVersion(event.getOldValue());
			List<InstanceEvent> newEvents = event.getValue().stream()
					.filter((e) -> e.getVersion() > lastKnownVersion).collect(Collectors.toList());
			HazelcastEventStore.this.publish(newEvents);
		}
	}, true);
}
 

@Test
void delete() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	String sessionId = "testSessionId";

	this.repository.deleteById(sessionId);

	verify(this.sessions, times(1)).remove(eq(sessionId));
	verifyZeroInteractions(this.sessions);
}
 

@Test
void getSessionFound() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	MapSession saved = new MapSession();
	saved.setAttribute("savedName", "savedValue");
	given(this.sessions.get(eq(saved.getId()))).willReturn(saved);

	HazelcastSession session = this.repository.findById(saved.getId());

	assertThat(session.getId()).isEqualTo(saved.getId());
	assertThat(session.<String>getAttribute("savedName")).isEqualTo("savedValue");
	verify(this.sessions, times(1)).get(eq(saved.getId()));
	verifyZeroInteractions(this.sessions);
}
 

@Test
void getSessionExpired() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	MapSession expired = new MapSession();
	expired.setLastAccessedTime(Instant.now().minusSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS + 1));
	given(this.sessions.get(eq(expired.getId()))).willReturn(expired);

	HazelcastSession session = this.repository.findById(expired.getId());

	assertThat(session).isNull();
	verify(this.sessions, times(1)).get(eq(expired.getId()));
	verify(this.sessions, times(1)).remove(eq(expired.getId()));
	verifyZeroInteractions(this.sessions);
}
 

@Test
void getSessionNotFound() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	String sessionId = "testSessionId";

	HazelcastSession session = this.repository.findById(sessionId);

	assertThat(session).isNull();
	verify(this.sessions, times(1)).get(eq(sessionId));
	verifyZeroInteractions(this.sessions);
}
 

@Test
void saveUnchangedFlushModeImmediate() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	this.repository.setFlushMode(FlushMode.IMMEDIATE);

	HazelcastSession session = this.repository.createSession();
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));

	this.repository.save(session);
	verifyZeroInteractions(this.sessions);
}
 

@Test
void saveUnchangedFlushModeOnSave() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	HazelcastSession session = this.repository.createSession();
	this.repository.save(session);
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));

	this.repository.save(session);
	verifyZeroInteractions(this.sessions);
}
 

@Test
void saveUpdatedLastAccessedTimeFlushModeImmediate() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	this.repository.setFlushMode(FlushMode.IMMEDIATE);

	HazelcastSession session = this.repository.createSession();
	session.setLastAccessedTime(Instant.now());
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));
	verify(this.sessions, times(1)).executeOnKey(eq(session.getId()), any(EntryProcessor.class));

	this.repository.save(session);
	verifyZeroInteractions(this.sessions);
}
 

@Test
void saveUpdatedLastAccessedTimeFlushModeOnSave() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	HazelcastSession session = this.repository.createSession();
	session.setLastAccessedTime(Instant.now());
	verifyZeroInteractions(this.sessions);

	this.repository.save(session);
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));
	verifyZeroInteractions(this.sessions);
}
 

@Test
void removeAttributeFlushModeImmediate() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	this.repository.setFlushMode(FlushMode.IMMEDIATE);

	HazelcastSession session = this.repository.createSession();
	session.removeAttribute("testName");
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));
	verify(this.sessions, times(1)).executeOnKey(eq(session.getId()), any(EntryProcessor.class));

	this.repository.save(session);
	verifyZeroInteractions(this.sessions);
}
 

@Test
void removeAttributeFlushModeOnSave() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	HazelcastSession session = this.repository.createSession();
	session.removeAttribute("testName");
	verifyZeroInteractions(this.sessions);

	this.repository.save(session);
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));
	verifyZeroInteractions(this.sessions);
}
 

@Test
void saveUpdatedAttributeFlushModeImmediate() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	this.repository.setFlushMode(FlushMode.IMMEDIATE);

	HazelcastSession session = this.repository.createSession();
	session.setAttribute("testName", "testValue");
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));
	verify(this.sessions, times(1)).executeOnKey(eq(session.getId()), any(EntryProcessor.class));

	this.repository.save(session);
	verifyZeroInteractions(this.sessions);
}
 

@Test
void saveUpdatedAttributeFlushModeOnSave() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	HazelcastSession session = this.repository.createSession();
	session.setAttribute("testName", "testValue");
	verifyZeroInteractions(this.sessions);

	this.repository.save(session);
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));
	verifyZeroInteractions(this.sessions);
}
 

@Test
void saveNewFlushModeImmediate() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	this.repository.setFlushMode(FlushMode.IMMEDIATE);

	HazelcastSession session = this.repository.createSession();
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));
	verifyZeroInteractions(this.sessions);
}
 

@Test
void saveNewFlushModeOnSave() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	HazelcastSession session = this.repository.createSession();
	verifyZeroInteractions(this.sessions);

	this.repository.save(session);
	verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
			eq(TimeUnit.SECONDS));
	verifyZeroInteractions(this.sessions);
}
 

@Test
void createSessionCustomMaxInactiveInterval() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	int interval = 1;
	this.repository.setDefaultMaxInactiveInterval(interval);

	HazelcastSession session = this.repository.createSession();

	assertThat(session.getMaxInactiveInterval()).isEqualTo(Duration.ofSeconds(interval));
	verifyZeroInteractions(this.sessions);
}
 

@Test
void createSessionDefaultMaxInactiveInterval() {
	verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());

	HazelcastSession session = this.repository.createSession();

	assertThat(session.getMaxInactiveInterval()).isEqualTo(new MapSession().getMaxInactiveInterval());
	verifyZeroInteractions(this.sessions);
}