method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
ZigBeeCommandNotifier { public synchronized void addCommandListener(ZigBeeCommandListener commandListener) { commandListeners.add(commandListener); } ZigBeeCommandNotifier(ZigBeeNetworkManager networkManager); synchronized void addCommandListener(ZigBeeCommandListener commandListener); synchronized void removeCommandListener(ZigBeeCommandListener commandListener); synchronized void notifyCommandListeners(final ZigBeeCommand command); }### Answer:
@Test public void addCommandListener() throws Exception { ZigBeeNetworkManager mockedNetworkManager = Mockito.mock(ZigBeeNetworkManager.class); Mockito.when(mockedNetworkManager.getNotificationService()).thenReturn(new NotificationService()); ZigBeeCommandNotifier notifier = new ZigBeeCommandNotifier(mockedNetworkManager); ZigBeeCommandListener commandListener = Mockito.mock(ZigBeeCommandListener.class); notifier.addCommandListener(commandListener); Set<ZigBeeCommandListener> commandListeners = (Set<ZigBeeCommandListener>) TestUtilities .getField(ZigBeeCommandNotifier.class, notifier, "commandListeners"); assertEquals(1, commandListeners.size()); assertEquals(commandListener, commandListeners.iterator().next()); notifier.addCommandListener(commandListener); assertEquals(1, commandListeners.size()); notifier.addCommandListener(Mockito.mock(ZigBeeCommandListener.class)); assertEquals(2, commandListeners.size()); ZigBeeCommand command = Mockito.mock(ZigBeeCommand.class); notifier.notifyCommandListeners(command); Mockito.verify(commandListener, Mockito.timeout(TIMEOUT).times(1)).commandReceived(command); ZclCommand zclCommand = Mockito.mock(ZclCommand.class); Mockito.when(zclCommand.isDisableDefaultResponse()).thenReturn(true); notifier.notifyCommandListeners(zclCommand); Mockito.when(zclCommand.isDisableDefaultResponse()).thenReturn(false); notifier.notifyCommandListeners(zclCommand); notifier.removeCommandListener(commandListener); assertEquals(1, commandListeners.size()); }
|
### Question:
ZigBeeEndpoint { public void sendTransaction(ZigBeeCommand command) { command.setDestinationAddress(getEndpointAddress()); node.sendTransaction(command); } ZigBeeEndpoint(ZigBeeNode node, int endpoint); int getDeviceId(); void setDeviceId(int deviceId); int getDeviceVersion(); void setDeviceVersion(int deviceVersion); int getEndpointId(); Collection<Integer> getInputClusterIds(); boolean addInputCluster(ZclCluster cluster); ZclCluster getInputCluster(int clusterId); ZclCluster getOutputCluster(int clusterId); void setInputClusterIds(List<Integer> inputClusterIds); IeeeAddress getIeeeAddress(); ZigBeeEndpointAddress getEndpointAddress(); Collection<Integer> getOutputClusterIds(); void setOutputClusterIds(Collection<Integer> outputClusterIds); boolean addOutputCluster(ZclCluster cluster); int getProfileId(); void setProfileId(int profileId); ZigBeeNode getParentNode(); ZigBeeStatus addApplication(ZigBeeApplication application); ZigBeeApplication getApplication(int clusterId); void commandReceived(ZclCommand command); boolean updateEndpoint(ZigBeeEndpoint endpoint); ZigBeeEndpointDao getDao(); void setDao(ZigBeeEndpointDao dao); void sendTransaction(ZigBeeCommand command); Future<CommandResult> sendTransaction(ZigBeeCommand command, ZigBeeTransactionMatcher responseMatcher); NotificationService getNotificationService(); @Override String toString(); }### Answer:
@Test public void sendTransaction() { ZigBeeEndpoint endpoint = getEndpoint(); ZclCommand command = mockZclCommand(DefaultResponse.class); ZigBeeTransactionMatcher matcher = Mockito.mock(ZigBeeTransactionMatcher.class); endpoint.sendTransaction(command, matcher); Mockito.verify(endpoint.getParentNode(), Mockito.timeout(TIMEOUT).times(1)).sendTransaction(command, matcher); endpoint.sendTransaction(command); Mockito.verify(endpoint.getParentNode(), Mockito.timeout(TIMEOUT).times(1)).sendTransaction(command); }
|
### Question:
ZigBeeEndpoint { public int getDeviceId() { return deviceId; } ZigBeeEndpoint(ZigBeeNode node, int endpoint); int getDeviceId(); void setDeviceId(int deviceId); int getDeviceVersion(); void setDeviceVersion(int deviceVersion); int getEndpointId(); Collection<Integer> getInputClusterIds(); boolean addInputCluster(ZclCluster cluster); ZclCluster getInputCluster(int clusterId); ZclCluster getOutputCluster(int clusterId); void setInputClusterIds(List<Integer> inputClusterIds); IeeeAddress getIeeeAddress(); ZigBeeEndpointAddress getEndpointAddress(); Collection<Integer> getOutputClusterIds(); void setOutputClusterIds(Collection<Integer> outputClusterIds); boolean addOutputCluster(ZclCluster cluster); int getProfileId(); void setProfileId(int profileId); ZigBeeNode getParentNode(); ZigBeeStatus addApplication(ZigBeeApplication application); ZigBeeApplication getApplication(int clusterId); void commandReceived(ZclCommand command); boolean updateEndpoint(ZigBeeEndpoint endpoint); ZigBeeEndpointDao getDao(); void setDao(ZigBeeEndpointDao dao); void sendTransaction(ZigBeeCommand command); Future<CommandResult> sendTransaction(ZigBeeCommand command, ZigBeeTransactionMatcher responseMatcher); NotificationService getNotificationService(); @Override String toString(); }### Answer:
@Test public void testGetDeviceId() { ZigBeeEndpoint endpoint = getEndpoint(); endpoint.setDeviceId(9999); assertEquals(9999, endpoint.getDeviceId()); }
|
### Question:
AttributeInformation implements ZclListItemField, Comparable<AttributeInformation> { @Override public int compareTo(AttributeInformation other) { return Integer.compare(identifier, other.getIdentifier()); } ZclDataType getDataType(); void setDataType(ZclDataType dataType); int getIdentifier(); void setIdentifier(int identifier); @Override void serialize(final ZigBeeSerializer serializer); @Override void deserialize(final ZigBeeDeserializer deserializer); @Override int compareTo(AttributeInformation other); @Override String toString(); }### Answer:
@Test public void compareTo() { Set<AttributeInformation> infoSet = new HashSet<AttributeInformation>(); AttributeInformation attr; attr = new AttributeInformation(); attr.setIdentifier(10); infoSet.add(attr); attr = new AttributeInformation(); attr.setIdentifier(9); infoSet.add(attr); attr = new AttributeInformation(); attr.setIdentifier(6); infoSet.add(attr); assertEquals(3, infoSet.size()); assertEquals(10, Collections.max(infoSet).getIdentifier()); }
|
### Question:
OffWithEffectCommand extends ZclOnOffCommand { @Override public void deserialize(final ZclFieldDeserializer deserializer) { effectIdentifier = (Integer) deserializer.deserialize(ZclDataType.UNSIGNED_8_BIT_INTEGER); effectVariant = (Integer) deserializer.deserialize(ZclDataType.UNSIGNED_8_BIT_INTEGER); } @Deprecated OffWithEffectCommand(); OffWithEffectCommand(
Integer effectIdentifier,
Integer effectVariant); Integer getEffectIdentifier(); @Deprecated void setEffectIdentifier(final Integer effectIdentifier); Integer getEffectVariant(); @Deprecated void setEffectVariant(final Integer effectVariant); @Override void serialize(final ZclFieldSerializer serializer); @Override void deserialize(final ZclFieldDeserializer deserializer); @Override String toString(); static int CLUSTER_ID; static int COMMAND_ID; }### Answer:
@Test public void deserialize() { int[] packet = getPacketData("01 12 40 00 00"); OffWithEffectCommand command = new OffWithEffectCommand(null, null); DefaultDeserializer deserializer = new DefaultDeserializer(packet); ZclFieldDeserializer fieldDeserializer = new ZclFieldDeserializer(deserializer); ZclHeader zclHeader = new ZclHeader(fieldDeserializer); System.out.println(zclHeader); command.deserialize(fieldDeserializer); System.out.println(command); assertEquals(Integer.valueOf(0), command.getEffectIdentifier()); assertEquals(Integer.valueOf(0), command.getEffectVariant()); }
|
### Question:
ConBeeVersionResponse extends ConBeeFrameResponse { public int getVersion() { return version; } ConBeeVersionResponse(final int[] response); int getVersion(); @Override String toString(); }### Answer:
@Test public void readMacAddress() { ConBeeVersionResponse readParameter = new ConBeeVersionResponse( new int[] { 0x0D, 0x02, 0x00, 0x09, 0x00, 0x00, 0x05, 0x1B, 0x26, 0xA2, 0xFF }); System.out.println(readParameter); assertEquals(2, readParameter.getSequence()); assertEquals(0x261B0500, readParameter.getVersion()); }
|
### Question:
XBeeHardwareVersionResponse extends XBeeFrame implements XBeeResponse { @Override public void deserialize(int[] incomingData) { initialiseDeserializer(incomingData); frameId = deserializeInt8(); deserializeAtCommand(); commandStatus = deserializeCommandStatus(); if (commandStatus != CommandStatus.OK || isComplete()) { return; } hardwareVersion = deserializeData(); } Integer getFrameId(); CommandStatus getCommandStatus(); int[] getHardwareVersion(); @Override void deserialize(int[] incomingData); @Override String toString(); }### Answer:
@Test public void test() { XBeeHardwareVersionResponse event = new XBeeHardwareVersionResponse(); event.deserialize(getPacketData("00 07 88 01 48 56 00 19 48 77")); System.out.println(event); assertEquals(0x88, event.getFrameType()); }
|
### Question:
XBeeResponseFactory { public static XBeeResponse getXBeeFrame(int[] data) { Class<?> xbeeClass = null; if (data[2] == 0x88) { xbeeClass = atCommands.get((data[4] << 8) + data[5]); } if (xbeeClass == null) { xbeeClass = events.get(data[2]); } if (xbeeClass == null) { return null; } Constructor<?> ctor; try { ctor = xbeeClass.getConstructor(); XBeeResponse xbeeFrame = (XBeeResponse) ctor.newInstance(); xbeeFrame.deserialize(data); return xbeeFrame; } catch (Exception e) { logger.debug("Error creating instance of XBeeResponse", e); } return null; } static XBeeResponse getXBeeFrame(int[] data); }### Answer:
@Test public void testGetResponse1() { int[] data = getPacketData("00 07 8B 8F F7 7B 00 00 40 33"); XBeeResponse frame = XBeeResponseFactory.getXBeeFrame(data); assertTrue(frame instanceof XBeeTransmitStatusResponse); System.out.println(frame); XBeeTransmitStatusResponse event = (XBeeTransmitStatusResponse) frame; assertEquals(Integer.valueOf(143), event.getFrameId()); assertEquals(Integer.valueOf(0), event.getTransmitRetryCount()); assertEquals(DeliveryStatus.SUCCESS, event.getDeliveryStatus()); assertEquals(DiscoveryStatus.EXTENDED_TIMEOUT_DISCOVERY, event.getDiscoveryStatus()); }
@Test public void testGetResponse2() { int[] data = getPacketData("00 05 88 10 4F 49 02 CD"); XBeeResponse frame = XBeeResponseFactory.getXBeeFrame(data); assertTrue(frame instanceof XBeePanIdResponse); System.out.println(frame); XBeePanIdResponse event = (XBeePanIdResponse) frame; assertEquals(CommandStatus.INVALID_COMMAND, event.getCommandStatus()); }
|
### Question:
ZigBeeDongleXBee implements ZigBeeTransportTransmit, XBeeEventListener { @Override public String getVersionString() { return versionString; } ZigBeeDongleXBee(final ZigBeePort serialPort); @Override ZigBeeStatus initialize(); @Override ZigBeeStatus startup(boolean reinitialize); @Override void shutdown(); @Override IeeeAddress getIeeeAddress(); @Override Integer getNwkAddress(); @Override void sendCommand(final int msgTag, final ZigBeeApsFrame apsFrame); @Override void setZigBeeTransportReceive(ZigBeeTransportReceive zigbeeTransportReceive); @Override void xbeeEventReceived(XBeeEvent event); @Override ZigBeeChannel getZigBeeChannel(); @Override ZigBeeStatus setZigBeeChannel(ZigBeeChannel channel); @Override int getZigBeePanId(); @Override ZigBeeStatus setZigBeePanId(int panId); @Override ExtendedPanId getZigBeeExtendedPanId(); @Override ZigBeeStatus setZigBeeExtendedPanId(ExtendedPanId extendedPanId); @Override ZigBeeStatus setZigBeeNetworkKey(final ZigBeeKey key); @Override ZigBeeKey getZigBeeNetworkKey(); @Override String getVersionString(); @Override ZigBeeStatus setTcLinkKey(ZigBeeKey key); @Override ZigBeeKey getTcLinkKey(); @Override void updateTransportConfig(TransportConfig configuration); }### Answer:
@Test public void getVersionString() { ZigBeeDongleXBee dongle = new ZigBeeDongleXBee(null); assertEquals("Unknown", dongle.getVersionString()); }
|
### Question:
ConBeeVersionRequest extends ConBeeFrameRequest { @Override public int[] getOutputBuffer() { super.getOutputBuffer(); serializeUInt8(VERSION); serializeUInt8(sequence); serializeUInt8(0); serializeUInt16(9); serializeUInt32(0); return copyOutputBuffer(); } @Override int[] getOutputBuffer(); @Override String toString(); }### Answer:
@Test public void test() { ConBeeVersionRequest request = new ConBeeVersionRequest(); request.setSequence(0x02); System.out.println(request); assertTrue(Arrays.equals(new int[] { 0x0D, 0x02, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE8, 0xFF }, request.getOutputBuffer())); }
|
### Question:
EzspAddEndpointResponse extends EzspFrameResponse { public EzspStatus getStatus() { return status; } EzspAddEndpointResponse(int[] inputBuffer); EzspStatus getStatus(); void setStatus(EzspStatus status); @Override String toString(); static final int FRAME_ID; }### Answer:
@Test public void testVersionError() { EzspFrame.setEzspVersion(4); EzspAddEndpointResponse response = new EzspAddEndpointResponse(getPacketData("02 80 02 36")); System.out.println(response); assertEquals(2, response.getSequenceNumber()); assertEquals(true, response.isResponse()); assertEquals(EzspAddEndpointResponse.FRAME_ID, response.getFrameId()); assertEquals(EzspStatus.EZSP_ERROR_INVALID_VALUE, response.getStatus()); }
|
### Question:
EzspNeighborCountResponse extends EzspFrameResponse { public int getValue() { return value; } EzspNeighborCountResponse(int[] inputBuffer); int getValue(); void setValue(int value); @Override String toString(); static final int FRAME_ID; }### Answer:
@Test public void testVersion() { EzspFrame.setEzspVersion(4); EzspNeighborCountResponse response = new EzspNeighborCountResponse(getPacketData("28 80 7A 01")); System.out.println(response); assertEquals(true, response.isResponse()); assertEquals(EzspNeighborCountResponse.FRAME_ID, response.getFrameId()); assertEquals(1, response.getValue()); }
|
### Question:
EzspIncomingSenderEui64Handler extends EzspFrameResponse { public IeeeAddress getSenderEui64() { return senderEui64; } EzspIncomingSenderEui64Handler(int[] inputBuffer); IeeeAddress getSenderEui64(); void setSenderEui64(IeeeAddress senderEui64); @Override String toString(); static final int FRAME_ID; }### Answer:
@Test public void testReceive1() { EzspFrame.setEzspVersion(4); EzspIncomingSenderEui64Handler incomingMessageHandler = new EzspIncomingSenderEui64Handler( getPacketData("1B 94 FF 00 62 E0 45 BE 0B 00 6F 0D 00")); System.out.println(incomingMessageHandler); assertEquals(0x62, incomingMessageHandler.getFrameId()); assertEquals(new IeeeAddress("000D6F000BBE45E0"), incomingMessageHandler.getSenderEui64()); }
|
### Question:
EzspStartScanResponse extends EzspFrameResponse { public EmberStatus getStatus() { return status; } EzspStartScanResponse(int[] inputBuffer); EmberStatus getStatus(); void setStatus(EmberStatus status); @Override String toString(); static final int FRAME_ID; }### Answer:
@Test public void testVersionError() { EzspStartScanResponse response = new EzspStartScanResponse(getPacketData("03 80 1A 35")); assertEquals(3, response.getSequenceNumber()); assertEquals(true, response.isResponse()); assertEquals(EzspStartScanResponse.FRAME_ID, response.getFrameId()); assertEquals(EmberStatus.EMBER_MAC_INVALID_CHANNEL_MASK, response.getStatus()); }
|
### Question:
EzspSetValueRequest extends EzspFrameRequest { public void setValue(int[] value) { this.value = value; } EzspSetValueRequest(); EzspValueId getValueId(); void setValueId(EzspValueId valueId); int[] getValue(); void setValue(int[] value); @Override int[] serialize(); @Override String toString(); static final int FRAME_ID; }### Answer:
@Test public void testSetValue() throws Exception { EzspFrame.setEzspVersion(4); EzspSetValueRequest request = new EzspSetValueRequest(); TestUtilities.setField(EzspFrame.class, request, "sequenceNumber", 2); request.setValueId(EzspValueId.EZSP_VALUE_APS_FRAME_COUNTER); request.setValue(new int[] { 1, 2, 3, 4 }); System.out.println(request); assertTrue(Arrays.equals(getPacketData("02 00 AB 24 04 01 02 03 04"), request.serialize())); }
|
### Question:
ConBeeDeviceStateRequest extends ConBeeFrameRequest { @Override public int[] getOutputBuffer() { super.getOutputBuffer(); serializeUInt8(DEVICE_STATE); serializeUInt8(sequence); serializeUInt8(0); serializeUInt16(8); serializeUInt8(0); serializeUInt8(0); serializeUInt8(0); return copyOutputBuffer(); } @Override int[] getOutputBuffer(); @Override String toString(); }### Answer:
@Test public void doRequest() { ConBeeDeviceStateRequest request = new ConBeeDeviceStateRequest(); request.setSequence(0); System.out.println(request); assertTrue(Arrays.equals(new int[] { 0x07, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0xF1, 0xFF }, request.getOutputBuffer())); }
|
### Question:
EzspSetConfigurationValueResponse extends EzspFrameResponse { public EzspStatus getStatus() { return status; } EzspSetConfigurationValueResponse(int[] inputBuffer); EzspStatus getStatus(); void setStatus(EzspStatus status); @Override String toString(); static final int FRAME_ID; }### Answer:
@Test public void testVersion() { EzspFrame.setEzspVersion(4); EzspSetConfigurationValueResponse response = new EzspSetConfigurationValueResponse( getPacketData("02 80 53 00")); System.out.println(response); assertEquals(2, response.getSequenceNumber()); assertEquals(true, response.isResponse()); assertEquals(EzspSetConfigurationValueResponse.FRAME_ID, response.getFrameId()); assertEquals(EzspStatus.EZSP_SUCCESS, response.getStatus()); }
|
### Question:
EzspFrameResponse extends EzspFrame { public boolean isCallbackPending() { return callbackPending; } protected EzspFrameResponse(int[] inputBuffer); boolean isCallbackPending(); }### Answer:
@Test public void testResponse() { EzspFrame.setEzspVersion(4); EzspNoCallbacksResponse response = new EzspNoCallbacksResponse(new int[] { 0x2C, 0x88, 0x07 }); System.out.println(response); assertFalse(response.isCallbackPending()); response = new EzspNoCallbacksResponse(new int[] { 0x2C, 0x8C, 0x07 }); System.out.println(response); assertTrue(response.isCallbackPending()); }
|
### Question:
AshFrameNak extends AshFrame { public AshFrameNak(int ackNum) { this.frameType = FrameType.NAK; this.ackNum = ackNum; } AshFrameNak(int ackNum); AshFrameNak(int[] frameBuffer); @Override String toString(); }### Answer:
@Test public void testAshFrameNak() { AshFrameNak frame; frame = new AshFrameNak(0); System.out.println(frame); assertTrue(Arrays.equals(new int[] { 255, 255, 126 }, frame.getOutputBuffer())); }
|
### Question:
AshFrameAck extends AshFrame { public AshFrameAck(int ackNum) { this.frameType = FrameType.ACK; this.ackNum = ackNum; } AshFrameAck(int ackNum); AshFrameAck(int[] frameBuffer); @Override String toString(); }### Answer:
@Test public void testAshFrameAck() { AshFrameAck frame; AshFrame inFrame; frame = new AshFrameAck(4); System.out.println(frame); assertTrue(Arrays.equals(new int[] { 132, 48, 252, 126 }, frame.getOutputBuffer())); inFrame = AshFrame.createFromInput(new int[] { 132, 48, 252 }); assertTrue(inFrame instanceof AshFrameAck); assertEquals(4, inFrame.getAckNum()); frame = new AshFrameAck(7); System.out.println(frame); assertTrue(Arrays.equals(new int[] { 135, 0, 159, 126 }, frame.getOutputBuffer())); inFrame = AshFrame.createFromInput(new int[] { 135, 0, 159 }); assertTrue(inFrame instanceof AshFrameAck); assertEquals(7, inFrame.getAckNum()); }
|
### Question:
AshFrameRst extends AshFrame { public AshFrameRst() { this.frameType = FrameType.RST; } AshFrameRst(); AshFrameRst(int[] frameBuffer); @Override int[] getOutputBuffer(); @Override String toString(); }### Answer:
@Test public void testAshFrameRst() { AshFrameRst frame; frame = new AshFrameRst(); System.out.println(frame); assertTrue(Arrays.equals(new int[] { 26, 192, 56, 188, 126 }, frame.getOutputBuffer())); AshFrame inFrame = AshFrame.createFromInput(new int[] { 192, 56, 188 }); assertTrue(inFrame instanceof AshFrameRst); }
|
### Question:
EmberFirmwareUpdateHandler { private boolean getBlPrompt() { int[] matcher = new int[] { 'B', 'L', ' ', '>' }; int matcherCount = 0; int retryCount = 0; while (retryCount < MENU_MAX_RETRIES) { try { Thread.sleep(1500); } catch (InterruptedException e) { } serialPort.purgeRxBuffer(); serialPort.write(CRN); long finish = System.currentTimeMillis() + 250; while (System.currentTimeMillis() < finish) { int val = serialPort.read(250); if (val == -1) { break; } logger.trace("GET PROMPT: {}", String.format("%02X %c", val, val)); if (val != matcher[matcherCount]) { matcherCount = 0; continue; } matcherCount++; if (matcherCount == matcher.length) { return true; } } retryCount++; } logger.debug("Ember bootloader: Unable to get bootloader prompt."); transferComplete(ZigBeeTransportFirmwareStatus.FIRMWARE_UPDATE_FAILED); return false; } EmberFirmwareUpdateHandler(ZigBeeDongleEzsp dongle, InputStream firmware, ZigBeePort serialPort,
ZigBeeTransportFirmwareCallback callback); void startBootload(); void cancelUpdate(); }### Answer:
@Test public void testGetBlPrompt() { boolean response = getBlPrompt(CR + "BL >"); assertEquals(true, response); }
|
### Question:
EmberFirmwareUpdateHandler { private int getTransferResponse() { long start = System.currentTimeMillis(); while (!stopBootload) { int val = serialPort.read(); if (val == -1) { if (System.currentTimeMillis() - start > TIMEOUT) { return NAK; } continue; } else { return val; } } return NAK; } EmberFirmwareUpdateHandler(ZigBeeDongleEzsp dongle, InputStream firmware, ZigBeePort serialPort,
ZigBeeTransportFirmwareCallback callback); void startBootload(); void cancelUpdate(); }### Answer:
@Test public void testGetTransferResponse() { int response = getTransferResponse(sNAK); assertEquals(NAK, response); response = getTransferResponse(sACK); assertEquals(ACK, response); }
|
### Question:
SpiFrameHandler implements EzspProtocolHandler { @Override public void connect() { logger.debug("SPI: connect"); stateConnected = false; sendQueue.clear(); outputFrame(requestSpiVersion); } SpiFrameHandler(final EzspFrameHandler frameHandler); void setPollRate(int pollRate); @Override void start(final ZigBeePort port); @Override void setClosing(); @Override void close(); @Override boolean isAlive(); @Override void queueFrame(EzspFrameRequest request); @Override void connect(); @Override Future<EzspFrame> sendEzspRequestAsync(final EzspTransaction ezspTransaction); @Override EzspTransaction sendEzspTransaction(EzspTransaction ezspTransaction); int getSpiErrors(); @Override Future<EzspFrameResponse> eventWaitAsync(final Class<?> eventClass); @Override EzspFrameResponse eventWait(final Class<?> eventClass, int timeout); @Override Map<String, Long> getCounters(); }### Answer:
@Test public void testConnect() { portOutData = new ArrayList<>(); SpiFrameHandler handler = new SpiFrameHandler(Mockito.mock(EzspFrameHandler.class)); handler.start(new TestPort(Mockito.mock(InputStream.class), Mockito.mock(OutputStream.class))); handler.connect(); assertEquals(2, portOutData.size()); assertEquals(Integer.valueOf(0x0A), portOutData.get(0)); assertEquals(Integer.valueOf(0xA7), portOutData.get(1)); }
|
### Question:
TelegesisFrame { private boolean isHex(int value) { return ((value >= 0x30 && value <= 0x39) || (value >= 0x41 && value <= 0x46) || (value >= 0x61 && value <= 0x66)); } TelegesisStatusCode getStatus(); }### Answer:
@Test public void testIsHex() { TelegesisFrame frame = new TelegesisFrame(); List<Integer> allowed = Arrays.asList(new Integer[] { (int) '0', (int) '1', (int) '2', (int) '3', (int) '4', (int) '5', (int) '6', (int) '7', (int) '8', (int) '9', (int) 'A', (int) 'B', (int) 'C', (int) 'D', (int) 'E', (int) 'F', (int) 'a', (int) 'b', (int) 'c', (int) 'd', (int) 'e', (int) 'f' }); Method isHex; try { isHex = TelegesisFrame.class.getDeclaredMethod("isHex", new Class[] { int.class }); isHex.setAccessible(true); for (int value = 0; value < 256; value++) { assertEquals(allowed.contains(value), (boolean) isHex.invoke(frame, value)); } } catch (NoSuchMethodException | SecurityException | IllegalArgumentException | IllegalAccessException | InvocationTargetException e) { e.printStackTrace(); } }
|
### Question:
TelegesisFrame { protected boolean handleIncomingStatus(int[] data) { if (Arrays.equals(Arrays.copyOfRange(data, 0, 2), RESPONSE_OK)) { status = TelegesisStatusCode.SUCCESS; return true; } if (Arrays.equals(Arrays.copyOfRange(data, 0, 6), RESPONSE_ERROR)) { StringBuilder builder = new StringBuilder(); builder.append((char) data[6]); builder.append((char) data[7]); status = TelegesisStatusCode.getTelegesisStatusCode(Integer.parseInt(builder.toString(), 16)); return true; } return false; } TelegesisStatusCode getStatus(); }### Answer:
@Test public void testHandleIncomingStatus() { TelegesisFrame frame = new TelegesisFrame(); Method handleIncomingStatus; try { handleIncomingStatus = TelegesisFrame.class.getDeclaredMethod("handleIncomingStatus", new Class[] { int[].class }); handleIncomingStatus.setAccessible(true); assertTrue((boolean) handleIncomingStatus.invoke(frame, stringToIntArray("OK\r\n"))); assertTrue((boolean) handleIncomingStatus.invoke(frame, stringToIntArray("ERROR:20\r\n"))); } catch (NoSuchMethodException | SecurityException | IllegalArgumentException | IllegalAccessException | InvocationTargetException e) { e.printStackTrace(); } }
|
### Question:
TelegesisChangeChannelCommand extends TelegesisFrame implements TelegesisCommand { public void setChannel(Integer channel) { if (channel < 11 || channel > 26) { throw(new IllegalArgumentException("Illegal value passed for channel. Range is 11 to 26.")); } this.channel = channel; } void setChannel(Integer channel); @Override int[] serialize(); @Override boolean deserialize(int[] data); @Override String toString(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testChannelLow() { TelegesisChangeChannelCommand command = new TelegesisChangeChannelCommand(); command.setChannel(10); }
@Test(expected = IllegalArgumentException.class) public void testChannelHigh() { TelegesisChangeChannelCommand command = new TelegesisChangeChannelCommand(); command.setChannel(27); }
|
### Question:
TelegesisFirmwareUpdateHandler { private boolean getBlPrompt() { int[] matcher = new int[] { 'B', 'L', ' ', '>' }; int matcherCount = 0; int retryCount = 0; while (retryCount < MENU_MAX_RETRIES) { try { Thread.sleep(1500); } catch (InterruptedException e) { } serialPort.purgeRxBuffer(); serialPort.write(CRN); long finish = System.currentTimeMillis() + 250; while (System.currentTimeMillis() < finish) { int val = serialPort.read(250); if (val == -1) { break; } if (val != matcher[matcherCount]) { matcherCount = 0; continue; } matcherCount++; if (matcherCount == matcher.length) { return true; } } retryCount++; } logger.debug("Telegesis bootloader: Unable to get bootloader prompt."); transferComplete(ZigBeeTransportFirmwareStatus.FIRMWARE_UPDATE_FAILED); return false; } TelegesisFirmwareUpdateHandler(ZigBeeDongleTelegesis dongle, InputStream firmware, ZigBeePort serialPort,
ZigBeeTransportFirmwareCallback callback); void startBootload(); void cancelUpdate(); }### Answer:
@Test public void testGetBlPrompt() { boolean response = getBlPrompt(CR + "BL >"); assertEquals(true, response); }
|
### Question:
TelegesisFirmwareUpdateHandler { private int getTransferResponse() { long start = System.currentTimeMillis(); while (!stopBootload) { int val = serialPort.read(); if (val == -1) { if (System.currentTimeMillis() - start > TIMEOUT) { return NAK; } continue; } else { return val; } } return NAK; } TelegesisFirmwareUpdateHandler(ZigBeeDongleTelegesis dongle, InputStream firmware, ZigBeePort serialPort,
ZigBeeTransportFirmwareCallback callback); void startBootload(); void cancelUpdate(); }### Answer:
@Test public void testGetTransferResponse() { int response = getTransferResponse(sNAK); assertEquals(NAK, response); response = getTransferResponse(sACK); assertEquals(ACK, response); }
|
### Question:
AuthServerHealthIndicatorConfigurationProperties { public String getHealthUri() { return healthUri; } String getHealthUri(); void setHealthUri(String healthUri); }### Answer:
@Test public void testDefaultValues() { AuthServerHealthIndicatorConfigurationProperties sut = new AuthServerHealthIndicatorConfigurationProperties(); assertThat(sut.getHealthUri(), is("http: }
|
### Question:
AuthServerHealthIndicator extends AbstractHealthIndicator { @Override protected void doHealthCheck(Health.Builder builder) { try { restTemplate.headForHeaders(checkUrl); builder.up(); } catch (HttpServerErrorException | UnknownHttpStatusCodeException | ResourceAccessException e) { builder.down(e); } } AuthServerHealthIndicator(RestTemplate restTemplate, String checkUrl); }### Answer:
@Test public void healthIsUp() { when(restTemplate.headForHeaders("url")).thenReturn(new HttpHeaders()); Health.Builder builder = new Health.Builder(); sut.doHealthCheck(builder); assertThat(builder.build().getStatus(), is(Status.UP)); }
@Test public void healthIsDownWithServerError() { when(restTemplate.headForHeaders("url")).thenThrow(new HttpServerErrorException(INTERNAL_SERVER_ERROR)); Health.Builder builder = new Health.Builder(); sut.doHealthCheck(builder); assertThat(builder.build().getStatus(), is(Status.DOWN)); }
|
### Question:
CoffeeNetDiscoveryProperties { public Boolean isEnabled() { return enabled; } Boolean isEnabled(); void setEnabled(Boolean enabled); @Override String toString(); }### Answer:
@Test public void testDefaultValues() { CoffeeNetDiscoveryProperties sut = new CoffeeNetDiscoveryProperties(); assertThat(sut.isEnabled(), is(true)); }
|
### Question:
CoffeeNetDiscoveryInstanceProperties extends EurekaInstanceConfigBean { @Override public String getHostname() { return hostname; } CoffeeNetDiscoveryInstanceProperties(InetUtils inetUtils,
CoffeeNetConfigurationProperties coffeeNetConfigurationProperties); @Override String getHostname(); @Override void setHostname(String hostname); @Override void setEnvironment(Environment environment); @Override String toString(); }### Answer:
@Test public void defaultValues() { CoffeeNetDiscoveryInstanceProperties sut = new CoffeeNetDiscoveryInstanceProperties(new InetUtils( new InetUtilsProperties()), new CoffeeNetConfigurationProperties()); assertThat(sut.getHostname(), is("localhost")); }
|
### Question:
CoffeeNetDiscoveryInstanceProperties extends EurekaInstanceConfigBean { @Override public void setEnvironment(Environment environment) { String applicationName = coffeeNetConfigurationProperties.getApplicationName(); if (StringUtils.hasText(applicationName)) { this.setAppname(applicationName); this.setVirtualHostName(applicationName); this.setSecureVirtualHostName(applicationName); } } CoffeeNetDiscoveryInstanceProperties(InetUtils inetUtils,
CoffeeNetConfigurationProperties coffeeNetConfigurationProperties); @Override String getHostname(); @Override void setHostname(String hostname); @Override void setEnvironment(Environment environment); @Override String toString(); }### Answer:
@Test public void applicationName() { String brandNewApplicationName = "BrandNewApplicationName"; CoffeeNetConfigurationProperties coffeeNetConfigurationProperties = new CoffeeNetConfigurationProperties(); coffeeNetConfigurationProperties.setApplicationName(brandNewApplicationName); CoffeeNetDiscoveryInstanceProperties sut = new CoffeeNetDiscoveryInstanceProperties(new InetUtils( new InetUtilsProperties()), coffeeNetConfigurationProperties); sut.setEnvironment(new MockEnvironment()); assertThat(sut.getAppname(), is(brandNewApplicationName)); assertThat(sut.getVirtualHostName(), is(brandNewApplicationName)); assertThat(sut.getSecureVirtualHostName(), is(brandNewApplicationName)); }
@Test public void applicationNameIsUnknown() { CoffeeNetConfigurationProperties coffeeNetConfigurationProperties = new CoffeeNetConfigurationProperties(); coffeeNetConfigurationProperties.setApplicationName(""); CoffeeNetDiscoveryInstanceProperties sut = new CoffeeNetDiscoveryInstanceProperties(new InetUtils( new InetUtilsProperties()), coffeeNetConfigurationProperties); sut.setEnvironment(new MockEnvironment()); String unknownApplicationName = "unknown"; assertThat(sut.getAppname(), is(unknownApplicationName)); assertThat(sut.getVirtualHostName(), is(unknownApplicationName)); assertThat(sut.getSecureVirtualHostName(), is(unknownApplicationName)); }
|
### Question:
CoffeeNetLoggingConsoleProperties { public Boolean isEnabled() { return enabled; } Boolean isEnabled(); void setEnabled(Boolean enabled); @Override String toString(); }### Answer:
@Test public void testDefaultValues() { CoffeeNetLoggingConsoleProperties sut = new CoffeeNetLoggingConsoleProperties(); assertThat(sut.isEnabled(), is(nullValue())); }
|
### Question:
CoffeeNetLoggingProperties { public Boolean isEnabled() { return enabled; } Boolean isEnabled(); void setEnabled(Boolean enabled); @Override String toString(); }### Answer:
@Test public void testDefaultValues() { CoffeeNetLoggingProperties sut = new CoffeeNetLoggingProperties(); assertThat(sut.isEnabled(), is(true)); }
|
### Question:
MachineCoffeeNetUser extends AbstractCoffeeNetUser { @Override public String getEmail() { throw new UnsupportedOperationException(); } MachineCoffeeNetUser(String username, Collection<GrantedAuthority> authorities); @Override String getUsername(); @Override String getEmail(); @Override Collection<GrantedAuthority> getAuthorities(); @Override boolean isCoffeeNetAdmin(); @Override boolean isMachineUser(); @Override String toString(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void getEmailUnsupportedOperationException() { MachineCoffeeNetUser sut = new MachineCoffeeNetUser("username", emptyList()); sut.getEmail(); }
|
### Question:
AbstractCoffeeNetUser implements CoffeeNetUserDetails { @Override public boolean hasRoles(String... roles) { for (String role : roles) { Assert.isTrue(!role.startsWith("ROLE_"), role + " cannot start with ROLE_ (it is automatically added)"); if (!getAuthorities().contains(new SimpleGrantedAuthority("ROLE_" + role))) { return false; } } return true; } @Override boolean hasRoles(String... roles); @Override Set<String> getAuthoritiesAsString(); }### Answer:
@Test public void hasRoles() { CoffeeNetUserDetails coffeeNetUserDetails = new CoffeeNetUserDetailsStub(); assertThat(coffeeNetUserDetails.hasRoles("COFFEENET-ADMIN", "COFFEENET-USER"), is(true)); }
@Test public void hasRolesNotAll() { CoffeeNetUserDetails coffeeNetUserDetails = new CoffeeNetUserDetailsStub(); assertThat(coffeeNetUserDetails.hasRoles("COFFEENET-ADMIN", "COFFEENET-WRONG-USER"), is(false)); }
@Test public void hasRolesNot() { CoffeeNetUserDetails coffeeNetUserDetails = new CoffeeNetUserDetailsStub(); assertThat(coffeeNetUserDetails.hasRoles("COFFEENET-WRONG-USER"), is(false)); }
@Test public void hasRolesNotAndEmptyRole() { CoffeeNetUserDetails coffeeNetUserDetails = new CoffeeNetUserDetailsStub(); assertThat(coffeeNetUserDetails.hasRoles(), is(true)); }
@Test public void hasRolesProvidesEmpty() { CoffeeNetUserDetails coffeeNetUserDetails = new CoffeeNetUserDetailsStub(); assertThat(coffeeNetUserDetails.hasRoles(), is(true)); }
@Test public void hasRolesHasEmpty() { CoffeeNetUserDetails coffeeNetUserDetails = new CoffeeNetUserDetailsEmptyStub(); assertThat(coffeeNetUserDetails.hasRoles("COFFEENET-USER"), is(false)); }
|
### Question:
AbstractCoffeeNetUser implements CoffeeNetUserDetails { @Override public Set<String> getAuthoritiesAsString() { return getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(toSet()); } @Override boolean hasRoles(String... roles); @Override Set<String> getAuthoritiesAsString(); }### Answer:
@Test public void getAuthoritiesAsString() { CoffeeNetUserDetails coffeeNetUserDetails = new CoffeeNetUserDetailsStub(); assertThat(coffeeNetUserDetails.getAuthoritiesAsString(), is(hasItems("ROLE_COFFEENET-ADMIN", "ROLE_COFFEENET-USER"))); }
|
### Question:
HumanCoffeeNetUser extends AbstractCoffeeNetUser { @Override public boolean isCoffeeNetAdmin() { return getAuthorities().contains(new SimpleGrantedAuthority("ROLE_COFFEENET-ADMIN")); } HumanCoffeeNetUser(String username, String email, Collection<GrantedAuthority> authorities); @Override String getUsername(); @Override String getEmail(); @Override Collection<GrantedAuthority> getAuthorities(); @Override boolean isCoffeeNetAdmin(); @Override boolean isMachineUser(); @Override String toString(); }### Answer:
@Test public void isAdmin() { List<GrantedAuthority> authorities = singletonList(new SimpleGrantedAuthority("ROLE_COFFEENET-ADMIN")); HumanCoffeeNetUser sut = new HumanCoffeeNetUser("username", "email@coffeenet", authorities); assertThat(sut.isCoffeeNetAdmin(), is(true)); }
@Test public void isAdminNotAndEmptyAuthorities() { HumanCoffeeNetUser sut = new HumanCoffeeNetUser("username", "email@coffeenet", emptyList()); assertThat(sut.isCoffeeNetAdmin(), is(false)); }
@Test public void isAdminNotAndWrongAuthorities() { List<GrantedAuthority> authorities = singletonList(new SimpleGrantedAuthority("ROLE_NO")); HumanCoffeeNetUser sut = new HumanCoffeeNetUser("username", "email@coffeenet", authorities); assertThat(sut.isCoffeeNetAdmin(), is(false)); }
|
### Question:
IntegrationCoffeeNetCurrentUserService implements CoffeeNetCurrentUserService { @Override public Optional<CoffeeNetUserDetails> get() { Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); if (authentication == null) { return Optional.empty(); } Object principal = authentication.getPrincipal(); if (!(principal instanceof CoffeeNetUserDetails)) { return Optional.empty(); } return Optional.of((CoffeeNetUserDetails) principal); } @Override Optional<CoffeeNetUserDetails> get(); }### Answer:
@Test public void get() { CoffeeNetUserDetails principal = new HumanCoffeeNetUser("test", "[email protected]", new HashSet<>()); SecurityContextImpl context = new SecurityContextImpl(); context.setAuthentication(new UsernamePasswordAuthenticationToken(principal, null)); SecurityContextHolder.setContext(context); CoffeeNetUserDetails result = sut.get().get(); assertThat(result, is(principal)); }
@Test public void getWithoutAuthenticationInContext() { Optional<CoffeeNetUserDetails> coffeeNetUserDetails = sut.get(); MatcherAssert.assertThat(coffeeNetUserDetails.isPresent(), is(false)); }
@Test(expected = NoSuchElementException.class) public void getWithoutPrincipal() { SecurityContextImpl context = new SecurityContextImpl(); context.setAuthentication(new UsernamePasswordAuthenticationToken(null, null)); SecurityContextHolder.setContext(context); sut.get().get(); }
@Test(expected = NoSuchElementException.class) public void getWithoutCoffeenetPrincipal() { SecurityContextImpl context = new SecurityContextImpl(); context.setAuthentication(new UsernamePasswordAuthenticationToken(new Object(), null)); SecurityContextHolder.setContext(context); sut.get().get(); }
|
### Question:
CoffeeNetNavigationInterceptor extends HandlerInterceptorAdapter { @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) { if (modelAndView == null) { LOGGER.debug(" return; } String view = ofNullable(modelAndView.getViewName()).orElse(""); boolean isNotRedirect = !view.contains("redirect:"); if (isNotRedirect) { modelAndView.addObject("coffeenet", coffeeNetNavigationService.get()); LOGGER.debug(" } else { LOGGER.debug(" } } CoffeeNetNavigationInterceptor(CoffeeNetNavigationService coffeeNetNavigationService); @Override void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView); }### Answer:
@Test public void postHandleWithModelAndView() throws Exception { CoffeeNetNavigationInformation coffeeNetNavigationInformation = new CoffeeNetNavigationInformation(null, null, null, null, null); when(coffeeNetNavigationServiceMock.get()).thenReturn(coffeeNetNavigationInformation); ModelAndView modelAndView = new ModelAndView(); sut.postHandle(null, null, null, modelAndView); assertThat(modelAndView.getModelMap().containsKey("coffeenet")).isEqualTo(true); CoffeeNetNavigationInformation coffeenet = (CoffeeNetNavigationInformation) modelAndView .getModelMap().get("coffeenet"); Assertions.assertThat(coffeenet).isEqualTo(coffeeNetNavigationInformation); }
@Test public void postHandleWithoutModelAndView() throws Exception { sut.postHandle(null, null, null, null); verify(coffeeNetNavigationServiceMock, never()).get(); }
@Test public void postHandleIsRedirect() throws Exception { sut.postHandle(null, null, null, new ModelAndView("redirect:coffeeNetView")); verify(coffeeNetNavigationServiceMock, never()).get(); }
|
### Question:
CoffeeNetNavigationEndpoint implements Endpoint<CoffeeNetNavigationInformation> { @Override public CoffeeNetNavigationInformation invoke() { return coffeeNetNavigationService.get(); } CoffeeNetNavigationEndpoint(CoffeeNetNavigationService coffeeNetNavigationService); @Override String getId(); @Override boolean isEnabled(); @Override boolean isSensitive(); @Override CoffeeNetNavigationInformation invoke(); }### Answer:
@Test public void invokeWithEmptyUserRoles() { CurrentCoffeeNetUser currentCoffeeNetUser = new CurrentCoffeeNetUser("username", "email"); CoffeeNetApp coffeeNetApp = new CoffeeNetApp("NoRights", "urlNoRights", emptySet()); List<CoffeeNetApp> coffeeNetApps = singletonList(coffeeNetApp); CoffeeNetNavigationAppInformation coffeeNetNavigationAppInformation = new CoffeeNetNavigationAppInformation("", "", "", "", "", ""); CoffeeNetNavigationInformation coffeeNetNavigationInformation = new CoffeeNetNavigationInformation( currentCoffeeNetUser, coffeeNetApps, coffeeNetApp, "path", coffeeNetNavigationAppInformation); when(coffeeNetNavigationServiceMock.get()).thenReturn(coffeeNetNavigationInformation); CoffeeNetNavigationEndpoint sut = new CoffeeNetNavigationEndpoint(coffeeNetNavigationServiceMock); CoffeeNetNavigationInformation receivedCoffeeNetNavigationInformation = sut.invoke(); assertThat(receivedCoffeeNetNavigationInformation.getCoffeeNetApps(), is(coffeeNetApps)); assertThat(receivedCoffeeNetNavigationInformation.getCurrentCoffeeNetUser(), Is.is(currentCoffeeNetUser)); assertThat(receivedCoffeeNetNavigationInformation.getLogoutPath(), is("path")); assertThat(receivedCoffeeNetNavigationInformation.getProfileApp(), is(coffeeNetApp)); }
|
### Question:
CoffeeNetNavigationDataExtractor { String extractLogoutPath() { return coffeeNetNavigationProperties.getLogoutPath(); } CoffeeNetNavigationDataExtractor(CoffeeNetNavigationProperties coffeeNetNavigationProperties); }### Answer:
@Test public void extractLogoutPath() { String logoutPath = sut.extractLogoutPath(); assertThat(logoutPath).isSameAs("/logout"); }
|
### Question:
CoffeeNetNavigationDataExtractor { Optional<CurrentCoffeeNetUser> extractUser() { Optional<CurrentCoffeeNetUser> coffeeNetWebUser = Optional.empty(); Optional<CoffeeNetCurrentUserService> userService = getCoffeeNetCurrentUserService(); if (userService.isPresent()) { Optional<CoffeeNetUserDetails> coffeeNetUserDetails = userService.get().get(); if (coffeeNetUserDetails.isPresent()) { String username = coffeeNetUserDetails.get().getUsername(); String email = coffeeNetUserDetails.get().getEmail(); coffeeNetWebUser = Optional.of(new CurrentCoffeeNetUser(username, email)); } } return coffeeNetWebUser; } CoffeeNetNavigationDataExtractor(CoffeeNetNavigationProperties coffeeNetNavigationProperties); }### Answer:
@Test public void extractUser() { sut.registerService(CoffeeNetNavigationDataExtractor.CoffeeNetServices.USER_SERVICE, coffeeNetCurrentUserServiceMock); Optional<CoffeeNetUserDetails> user = of(new HumanCoffeeNetUser("username", "email", emptyList())); when(coffeeNetCurrentUserServiceMock.get()).thenReturn(user); Optional<CurrentCoffeeNetUser> coffeeNetWebUser = sut.extractUser(); assertThat(coffeeNetWebUser.get().getEmail()).isSameAs("email"); assertThat(coffeeNetWebUser.get().getUsername()).isSameAs("username"); }
@Test public void extractUserNoUserService() { Optional<CurrentCoffeeNetUser> coffeeNetWebUser = sut.extractUser(); assertThat(coffeeNetWebUser).isSameAs(Optional.empty()); }
|
### Question:
CurrentCoffeeNetUser { public String getAvatar() { try { MessageDigest md5 = MessageDigest.getInstance("MD5"); final byte[] emailAsBytes = email.getBytes(UTF_8); final String md5HashOfEmail = Hex.encodeHexString(md5.digest(emailAsBytes)); return format("https: } catch (NoSuchAlgorithmException e) { LOGGER.debug("/> Fallback to default avatar", e); } return "/img/default_avatar.jpg"; } CurrentCoffeeNetUser(String username, String email); String getUsername(); String getEmail(); String getAvatar(); }### Answer:
@Test public void getAvatarWithGravatar() { CurrentCoffeeNetUser currentCoffeeNetUser = new CurrentCoffeeNetUser("username", "username@coffeenet"); assertThat(currentCoffeeNetUser.getAvatar(), is("https: }
|
### Question:
CoffeeNetWebMvcConfigurerAdapter extends WebMvcConfigurerAdapter { @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(coffeeNetNavigationInterceptor).addPathPatterns("/**"); LOGGER.info(" } CoffeeNetWebMvcConfigurerAdapter(CoffeeNetNavigationInterceptor coffeeNetNavigationInterceptor); @Override void addInterceptors(InterceptorRegistry registry); }### Answer:
@Test public void addInterceptors() { InterceptorRegistry interceptorRegistryMock = mock(InterceptorRegistry.class); InterceptorRegistration interceptorRegistrationMock = mock(InterceptorRegistration.class); when(interceptorRegistryMock.addInterceptor(coffeeNetNavigationInterceptorMock)).thenReturn( interceptorRegistrationMock); sut.addInterceptors(interceptorRegistryMock); verify(interceptorRegistryMock).addInterceptor(coffeeNetNavigationInterceptorMock); verify(interceptorRegistrationMock).addPathPatterns("/**"); }
|
### Question:
DataRowEditController extends PluginController { @GetMapping("/**") public String init(Model model) { model.addAttribute("baseUrl", URI); model.addAttribute("lng", LocaleContextHolder.getLocale().getLanguage()); model.addAttribute("fallbackLng", appSettings.getLanguageCode()); model.addAttribute( "dataExplorerBaseUrl", menuReaderService.findMenuItemPath(DataExplorerController.ID)); return VIEW_TEMPLATE; } DataRowEditController(MenuReaderService menuReaderService, AppSettings appSettings); @GetMapping("/**") String init(Model model); static final String ID; static final String URI; static final String VIEW_TEMPLATE; }### Answer:
@Test void testInit() throws Exception { mockMvc .perform(get(DataRowEditController.URI)) .andExpect(status().isOk()) .andExpect(view().name(DataRowEditController.VIEW_TEMPLATE)) .andExpect(model().attribute("baseUrl", "/plugin/data-row-edit")) .andExpect(model().attribute("lng", "en")) .andExpect(model().attribute("fallbackLng", "DDEEFF")); }
|
### Question:
PermissionSetUtils { public static PermissionSet paramValueToPermissionSet(String paramValue) { switch (paramValue.toUpperCase()) { case READMETA: return PermissionSet.READMETA; case COUNT: return PermissionSet.COUNT; case READ: return PermissionSet.READ; case WRITE: return PermissionSet.WRITE; case WRITEMETA: return PermissionSet.WRITEMETA; default: throw new IllegalArgumentException(format("Unknown PermissionSet '%s'", paramValue)); } } private PermissionSetUtils(); static PermissionSet getPermissionSet(AccessControlEntry accessControlEntry); static PermissionSet paramValueToPermissionSet(String paramValue); static Optional<String> getPermissionStringValue(LabelledPermission labelledPermission); static String getPermissionStringValue(PermissionSet permissionSet); static final String READMETA; static final String COUNT; static final String READ; static final String WRITE; static final String WRITEMETA; static final String UNEXPECTED_MASK_MESSAGE; }### Answer:
@Test void testParamValueToPermissionSetRead() { assertEquals(READ, paramValueToPermissionSet("read")); }
@Test void testParamValueToPermissionSetWrite() { assertEquals(WRITE, paramValueToPermissionSet("write")); }
@Test void testParamValueToPermissionSetWritemeta() { assertEquals(WRITEMETA, paramValueToPermissionSet("writemeta")); }
@Test void testParamValueToPermissionSetReadmeta() { assertEquals(READMETA, paramValueToPermissionSet("readmeta")); }
@Test void testParamValueToPermissionSetCount() { assertEquals(COUNT, paramValueToPermissionSet("count")); }
@Test void testParamValueToPermissionSetInvalid() { Exception exception = assertThrows( IllegalArgumentException.class, () -> PermissionSetUtils.paramValueToPermissionSet("test")); assertThat(exception.getMessage()).containsPattern("Unknown PermissionSet 'test'"); }
|
### Question:
PermissionSetUtils { public static Optional<String> getPermissionStringValue(LabelledPermission labelledPermission) { PermissionSet permissionSet = labelledPermission.getPermission(); String permissionStringValue = getPermissionStringValue(permissionSet); return Optional.ofNullable(permissionStringValue); } private PermissionSetUtils(); static PermissionSet getPermissionSet(AccessControlEntry accessControlEntry); static PermissionSet paramValueToPermissionSet(String paramValue); static Optional<String> getPermissionStringValue(LabelledPermission labelledPermission); static String getPermissionStringValue(PermissionSet permissionSet); static final String READMETA; static final String COUNT; static final String READ; static final String WRITE; static final String WRITEMETA; static final String UNEXPECTED_MASK_MESSAGE; }### Answer:
@Test void testGetPermissionStringValueLabelledPermissionNull() { LabelledPermission labelledPermission = mock(LabelledPermission.class); assertEquals(Optional.empty(), PermissionSetUtils.getPermissionStringValue(labelledPermission)); }
@Test void testGetPermissionStringValueInvalidMask() { PermissionSet permissionSet = new PermissionSet("name", 32, 'x'); assertThrows( IllegalArgumentException.class, () -> PermissionSetUtils.getPermissionStringValue(permissionSet)); }
|
### Question:
PermissionSetUtils { public static PermissionSet getPermissionSet(AccessControlEntry accessControlEntry) { int mask = accessControlEntry.getPermission().getMask(); switch (mask) { case READ_META_MASK: return PermissionSet.READMETA; case COUNT_MASK: return PermissionSet.COUNT; case READ_MASK: return PermissionSet.READ; case WRITE_MASK: return PermissionSet.WRITE; case WRITEMETA_MASK: return PermissionSet.WRITEMETA; default: throw new IllegalArgumentException(format(UNEXPECTED_MASK_MESSAGE, mask)); } } private PermissionSetUtils(); static PermissionSet getPermissionSet(AccessControlEntry accessControlEntry); static PermissionSet paramValueToPermissionSet(String paramValue); static Optional<String> getPermissionStringValue(LabelledPermission labelledPermission); static String getPermissionStringValue(PermissionSet permissionSet); static final String READMETA; static final String COUNT; static final String READ; static final String WRITE; static final String WRITEMETA; static final String UNEXPECTED_MASK_MESSAGE; }### Answer:
@Test void testGetPermissionSetInvalidMask() { AccessControlEntry accessControlEntry = mock(AccessControlEntry.class); Permission permission = when(mock(Permission.class).getMask()).thenReturn(32).getMock(); when(accessControlEntry.getPermission()).thenReturn(permission); assertThrows( IllegalArgumentException.class, () -> PermissionSetUtils.getPermissionSet(accessControlEntry)); }
|
### Question:
PermissionServiceDecorator implements PermissionService { @Override public void createAcl(ObjectIdentity objectIdentity) { checkSuOrSystem(objectIdentity.getType(), objectIdentity.getIdentifier().toString()); permissionService.createAcl(objectIdentity); } PermissionServiceDecorator(
PermissionService permissionService,
EntityHelper entityHelper,
UserRoleTools userRoleTools,
MutableAclService mutableAclService,
MutableAclClassService mutableAclClassService,
UserPermissionEvaluator userPermissionEvaluator); @Override Set<LabelledType> getLabelledTypes(); @Override Set<LabelledPermission> getPermissionsForObject(
ObjectIdentity objectIdentity, Set<Sid> sids, boolean isReturnInheritedPermissions); @Override void createAcl(ObjectIdentity objectIdentity); @Override void createPermission(Permission permission); @Override void createPermissions(Set<Permission> permissions); @Override void updatePermission(Permission permission); @Override void updatePermissions(Set<Permission> permissions); @Override void deletePermission(Sid sid, ObjectIdentity objectIdentity); @Override void addType(String typeId); @Override void deleteType(String typeId); @Override Map<String, Set<LabelledPermission>> getPermissionsForType(
String typeId, Set<Sid> sids, boolean isReturnInherited); @Override Map<String, Set<LabelledPermission>> getPermissionsForType(
String typeId, Set<Sid> sids, int page, int pageSize); @Override Set<LabelledPermission> getPermissions(Set<Sid> sids, boolean isReturnInherited); @Override Set<LabelledObject> getObjects(String typeId, int page, int pageSize); @Override Set<PermissionSet> getSuitablePermissionsForType(String typeId); @Override boolean exists(ObjectIdentity objectIdentity, Sid sid); static final String SUPERUSER; }### Answer:
@Test void testCreateAcl() { setSu(); ObjectIdentity objectIdentity = new ObjectIdentityImpl("type", "identifier"); permissionServiceDecorator.createAcl(objectIdentity); verify(permissionService).createAcl(objectIdentity); resetContext(); }
|
### Question:
PermissionServiceDecorator implements PermissionService { @Override public void addType(String typeId) { if (SecurityUtils.currentUserIsSuOrSystem()) { permissionService.addType(typeId); } else { throw new InsufficientPermissionsException( "type", typeId, Collections.singletonList(SUPERUSER)); } } PermissionServiceDecorator(
PermissionService permissionService,
EntityHelper entityHelper,
UserRoleTools userRoleTools,
MutableAclService mutableAclService,
MutableAclClassService mutableAclClassService,
UserPermissionEvaluator userPermissionEvaluator); @Override Set<LabelledType> getLabelledTypes(); @Override Set<LabelledPermission> getPermissionsForObject(
ObjectIdentity objectIdentity, Set<Sid> sids, boolean isReturnInheritedPermissions); @Override void createAcl(ObjectIdentity objectIdentity); @Override void createPermission(Permission permission); @Override void createPermissions(Set<Permission> permissions); @Override void updatePermission(Permission permission); @Override void updatePermissions(Set<Permission> permissions); @Override void deletePermission(Sid sid, ObjectIdentity objectIdentity); @Override void addType(String typeId); @Override void deleteType(String typeId); @Override Map<String, Set<LabelledPermission>> getPermissionsForType(
String typeId, Set<Sid> sids, boolean isReturnInherited); @Override Map<String, Set<LabelledPermission>> getPermissionsForType(
String typeId, Set<Sid> sids, int page, int pageSize); @Override Set<LabelledPermission> getPermissions(Set<Sid> sids, boolean isReturnInherited); @Override Set<LabelledObject> getObjects(String typeId, int page, int pageSize); @Override Set<PermissionSet> getSuitablePermissionsForType(String typeId); @Override boolean exists(ObjectIdentity objectIdentity, Sid sid); static final String SUPERUSER; }### Answer:
@Test void testAddType() { setSu(); permissionServiceDecorator.addType("entity-typeId"); verify(permissionService).addType("entity-typeId"); resetContext(); }
|
### Question:
PermissionServiceDecorator implements PermissionService { @Override public void deleteType(String typeId) { checkSuOrSystem("type", typeId); permissionService.deleteType(typeId); } PermissionServiceDecorator(
PermissionService permissionService,
EntityHelper entityHelper,
UserRoleTools userRoleTools,
MutableAclService mutableAclService,
MutableAclClassService mutableAclClassService,
UserPermissionEvaluator userPermissionEvaluator); @Override Set<LabelledType> getLabelledTypes(); @Override Set<LabelledPermission> getPermissionsForObject(
ObjectIdentity objectIdentity, Set<Sid> sids, boolean isReturnInheritedPermissions); @Override void createAcl(ObjectIdentity objectIdentity); @Override void createPermission(Permission permission); @Override void createPermissions(Set<Permission> permissions); @Override void updatePermission(Permission permission); @Override void updatePermissions(Set<Permission> permissions); @Override void deletePermission(Sid sid, ObjectIdentity objectIdentity); @Override void addType(String typeId); @Override void deleteType(String typeId); @Override Map<String, Set<LabelledPermission>> getPermissionsForType(
String typeId, Set<Sid> sids, boolean isReturnInherited); @Override Map<String, Set<LabelledPermission>> getPermissionsForType(
String typeId, Set<Sid> sids, int page, int pageSize); @Override Set<LabelledPermission> getPermissions(Set<Sid> sids, boolean isReturnInherited); @Override Set<LabelledObject> getObjects(String typeId, int page, int pageSize); @Override Set<PermissionSet> getSuitablePermissionsForType(String typeId); @Override boolean exists(ObjectIdentity objectIdentity, Sid sid); static final String SUPERUSER; }### Answer:
@Test void testDeleteType() { setSu(); permissionServiceDecorator.deleteType("entity-typeId"); verify(permissionService).deleteType("entity-typeId"); resetContext(); }
|
### Question:
PermissionServiceDecorator implements PermissionService { @Override public Set<LabelledObject> getObjects(String typeId, int page, int pageSize) { checkReadPermission(typeId, Collections.emptySet()); return permissionService.getObjects(typeId, page, pageSize); } PermissionServiceDecorator(
PermissionService permissionService,
EntityHelper entityHelper,
UserRoleTools userRoleTools,
MutableAclService mutableAclService,
MutableAclClassService mutableAclClassService,
UserPermissionEvaluator userPermissionEvaluator); @Override Set<LabelledType> getLabelledTypes(); @Override Set<LabelledPermission> getPermissionsForObject(
ObjectIdentity objectIdentity, Set<Sid> sids, boolean isReturnInheritedPermissions); @Override void createAcl(ObjectIdentity objectIdentity); @Override void createPermission(Permission permission); @Override void createPermissions(Set<Permission> permissions); @Override void updatePermission(Permission permission); @Override void updatePermissions(Set<Permission> permissions); @Override void deletePermission(Sid sid, ObjectIdentity objectIdentity); @Override void addType(String typeId); @Override void deleteType(String typeId); @Override Map<String, Set<LabelledPermission>> getPermissionsForType(
String typeId, Set<Sid> sids, boolean isReturnInherited); @Override Map<String, Set<LabelledPermission>> getPermissionsForType(
String typeId, Set<Sid> sids, int page, int pageSize); @Override Set<LabelledPermission> getPermissions(Set<Sid> sids, boolean isReturnInherited); @Override Set<LabelledObject> getObjects(String typeId, int page, int pageSize); @Override Set<PermissionSet> getSuitablePermissionsForType(String typeId); @Override boolean exists(ObjectIdentity objectIdentity, Sid sid); static final String SUPERUSER; }### Answer:
@Test void testGetObjects() { setSu(); permissionServiceDecorator.getObjects("entity-typeId", 10, 10); verify(permissionService).getObjects("entity-typeId", 10, 10); resetContext(); }
|
### Question:
UserRoleTools { public void checkRoleExists(String role) { if (getRole(role) == null) { throw new UnknownRoleException(role); } } UserRoleTools(
UserService userService,
DataService dataService,
UserPermissionEvaluator userPermissionEvaluator); void checkRoleExists(String role); void checkUserExists(String user); List<Sid> getSids(List<String> users, List<String> roles); static Optional<String> getUsername(Sid sid); static Optional<String> getRolename(Sid sid); static String getName(Sid sid); List<Sid> getRolesForSid(Sid sid); static final String ANONYMOUS; }### Answer:
@Test void testCheckRoleExists() { @SuppressWarnings("unchecked") Query<Role> query = mock(Query.class, RETURNS_SELF); Role role = mock(Role.class); when(query.findOne()).thenReturn(role); when(dataService.query(RoleMetadata.ROLE, Role.class)).thenReturn(query); assertDoesNotThrow(() -> userRoleTools.checkRoleExists("role")); }
@Test void testCheckRoleExistsUnknownRoleException() { @SuppressWarnings("unchecked") Query<Role> query = mock(Query.class, RETURNS_SELF); when(dataService.query(RoleMetadata.ROLE, Role.class)).thenReturn(query); assertThrows(UnknownRoleException.class, () -> userRoleTools.checkRoleExists("role")); }
|
### Question:
UserRoleTools { public void checkUserExists(String user) { if (userService.getUser(user) == null) { throw new UnknownUserException(user); } } UserRoleTools(
UserService userService,
DataService dataService,
UserPermissionEvaluator userPermissionEvaluator); void checkRoleExists(String role); void checkUserExists(String user); List<Sid> getSids(List<String> users, List<String> roles); static Optional<String> getUsername(Sid sid); static Optional<String> getRolename(Sid sid); static String getName(Sid sid); List<Sid> getRolesForSid(Sid sid); static final String ANONYMOUS; }### Answer:
@Test void testCheckUserExists() { User user = mock(User.class); when(userService.getUser("user")).thenReturn(user); assertDoesNotThrow(() -> userRoleTools.checkUserExists("user")); }
@Test void testCheckUserExistsUnknownUserException() { assertThrows(UnknownUserException.class, () -> userRoleTools.checkUserExists("user")); }
|
### Question:
UserRoleTools { public static Optional<String> getUsername(Sid sid) { if (sid instanceof PrincipalSid) { return Optional.of(((PrincipalSid) sid).getPrincipal()); } return Optional.empty(); } UserRoleTools(
UserService userService,
DataService dataService,
UserPermissionEvaluator userPermissionEvaluator); void checkRoleExists(String role); void checkUserExists(String user); List<Sid> getSids(List<String> users, List<String> roles); static Optional<String> getUsername(Sid sid); static Optional<String> getRolename(Sid sid); static String getName(Sid sid); List<Sid> getRolesForSid(Sid sid); static final String ANONYMOUS; }### Answer:
@Test void testGetUser() { assertEquals("test", getUsername(new PrincipalSid("test")).get()); }
|
### Question:
UserRoleTools { private Role getRole(String rolename) { return dataService .query(RoleMetadata.ROLE, Role.class) .eq(RoleMetadata.NAME, rolename) .findOne(); } UserRoleTools(
UserService userService,
DataService dataService,
UserPermissionEvaluator userPermissionEvaluator); void checkRoleExists(String role); void checkUserExists(String user); List<Sid> getSids(List<String> users, List<String> roles); static Optional<String> getUsername(Sid sid); static Optional<String> getRolename(Sid sid); static String getName(Sid sid); List<Sid> getRolesForSid(Sid sid); static final String ANONYMOUS; }### Answer:
@Test void testGetRole() { assertEquals("test", getRolename(new GrantedAuthoritySid("ROLE_test")).get()); }
|
### Question:
UserRoleTools { public static String getName(Sid sid) { Optional<String> name = getRolename(sid); if (!name.isPresent()) { name = getUsername(sid); } if (!name.isPresent()) { throw new IllegalStateException( "Sid should always be either a GrantedAuthoritySid or a PrincipalSid"); } return name.get(); } UserRoleTools(
UserService userService,
DataService dataService,
UserPermissionEvaluator userPermissionEvaluator); void checkRoleExists(String role); void checkUserExists(String user); List<Sid> getSids(List<String> users, List<String> roles); static Optional<String> getUsername(Sid sid); static Optional<String> getRolename(Sid sid); static String getName(Sid sid); List<Sid> getRolesForSid(Sid sid); static final String ANONYMOUS; }### Answer:
@Test void testGetNameRole() { assertEquals("test", getName(new GrantedAuthoritySid("ROLE_test"))); }
@Test void testGetName() { assertEquals("test", getName(new PrincipalSid("test"))); }
|
### Question:
UserRoleTools { public List<Sid> getSids(List<String> users, List<String> roles) { List<Sid> results = new ArrayList<>(); for (String user : users) { checkUserExists(user); results.add(createUserSid(user)); } for (String role : roles) { checkRoleExists(role); results.add(createRoleSid(role)); } return results; } UserRoleTools(
UserService userService,
DataService dataService,
UserPermissionEvaluator userPermissionEvaluator); void checkRoleExists(String role); void checkUserExists(String user); List<Sid> getSids(List<String> users, List<String> roles); static Optional<String> getUsername(Sid sid); static Optional<String> getRolename(Sid sid); static String getName(Sid sid); List<Sid> getRolesForSid(Sid sid); static final String ANONYMOUS; }### Answer:
@Test void testGetSids() { List<Sid> expected = Arrays.asList( new PrincipalSid("user1"), new PrincipalSid("user2"), new GrantedAuthoritySid("ROLE_role1"), new GrantedAuthoritySid("ROLE_role2")); Query query = mock(Query.class); doReturn(query).when(query).eq(RoleMetadata.NAME, "role1"); doReturn(query).when(query).eq(RoleMetadata.NAME, "role2"); doReturn(mock(Role.class)).when(query).findOne(); doReturn(mock(User.class)).when(userService).getUser("user1"); doReturn(mock(User.class)).when(userService).getUser("user2"); when(dataService.query(RoleMetadata.ROLE, Role.class)).thenReturn(query); when(query.findOne()).thenReturn(mock(Role.class)); assertTrue( userRoleTools .getSids(Arrays.asList("user1", "user2"), Arrays.asList("role1", "role2")) .containsAll(expected)); }
|
### Question:
UserRoleTools { List<Sid> sortSids(Set<Sid> sids) { List<Sid> result = new LinkedList<>(sids); result.sort(comparing(UserRoleTools::getName)); return result; } UserRoleTools(
UserService userService,
DataService dataService,
UserPermissionEvaluator userPermissionEvaluator); void checkRoleExists(String role); void checkUserExists(String user); List<Sid> getSids(List<String> users, List<String> roles); static Optional<String> getUsername(Sid sid); static Optional<String> getRolename(Sid sid); static String getName(Sid sid); List<Sid> getRolesForSid(Sid sid); static final String ANONYMOUS; }### Answer:
@Test void testSortSids() { Sid sid1 = new PrincipalSid("b"); Sid sid2 = new PrincipalSid("a"); Sid sid3 = new GrantedAuthoritySid("ROLE_b"); Sid sid4 = new GrantedAuthoritySid("ROLE_a"); LinkedList expected = new LinkedList<>(); expected.addAll(Arrays.asList(sid2, sid4, sid1, sid3)); assertEquals(expected, userRoleTools.sortSids(newHashSet(sid1, sid2, sid3, sid4))); }
|
### Question:
PermissionInheritanceResolver { public Set<LabelledPermission> getInheritedPermissions(Acl acl, Sid sid) { InheritedPermissionsResult inheritedPermissionsResult = getInheritedPermissionsResults(acl, sid); return convertToInheritedPermissions(inheritedPermissionsResult); } PermissionInheritanceResolver(UserRoleTools userRoleTools, EntityHelper entityHelper); Set<LabelledPermission> getInheritedPermissions(Acl acl, Sid sid); }### Answer:
@Test void testGetInheritedPermissions() { Sid user = mock(PrincipalSid.class); Sid role1Sid = new GrantedAuthoritySid("ROLE_role1"); Sid role2Sid = new GrantedAuthoritySid("ROLE_role2"); Sid role3Sid = new GrantedAuthoritySid("ROLE_role3"); Acl parentPackageAcl = PermissionTestUtils.getSinglePermissionAcl(role3Sid, 16, "parentPackageAcl"); Acl packageAcl = PermissionTestUtils.getSinglePermissionAcl(user, 4, "packageAcl", parentPackageAcl); Acl entityAcl = PermissionTestUtils.getSinglePermissionAcl(role2Sid, 8, "entityAcl", packageAcl); doReturn(Arrays.asList(role1Sid, role2Sid)).when(userRoleTools).getRolesForSid(user); doReturn(singletonList(role3Sid)).when(userRoleTools).getRolesForSid(role1Sid); InheritedPermissionsResult expected = getInheritedPermissionsResult(packageAcl, parentPackageAcl, role1Sid, role2Sid, role3Sid); assertEquals(expected, resolver.getInheritedPermissionsResults(entityAcl, user)); }
|
### Question:
RoleMembershipServiceImpl implements RoleMembershipService { @RunAsSystem @Override public void removeMembership(final RoleMembership roleMembership) { dataService.delete(ROLE_MEMBERSHIP, roleMembership); } RoleMembershipServiceImpl(
UserService userService,
RoleMembershipFactory roleMembershipFactory,
DataService dataService,
UserMetadata userMetadata,
RoleMetadata roleMetadata); @RunAsSystem @Override void addUserToRole(String username, String roleName); @RunAsSystem @Override void addUserToRole(final User user, final Role role); @RunAsSystem @Override void removeMembership(final RoleMembership roleMembership); @RunAsSystem @Override void updateMembership(RoleMembership roleMembership, Role newRole); @RunAsSystem @Override Collection<RoleMembership> getMemberships(Collection<Role> roles); }### Answer:
@Test void testRemoveMembership() { roleMembershipService.removeMembership(roleMembership); verify(dataService).delete(ROLE_MEMBERSHIP, roleMembership); }
|
### Question:
RoleMembershipServiceImpl implements RoleMembershipService { @RunAsSystem @Override public void updateMembership(RoleMembership roleMembership, Role newRole) { final RoleMembership membership = dataService.findOneById( RoleMembershipMetadata.ROLE_MEMBERSHIP, roleMembership.getId(), RoleMembership.class); if (membership == null) { throw new UnknownEntityException(roleMetadata, roleMembership.getId()); } membership.setRole(newRole); dataService.update(RoleMembershipMetadata.ROLE_MEMBERSHIP, membership); } RoleMembershipServiceImpl(
UserService userService,
RoleMembershipFactory roleMembershipFactory,
DataService dataService,
UserMetadata userMetadata,
RoleMetadata roleMetadata); @RunAsSystem @Override void addUserToRole(String username, String roleName); @RunAsSystem @Override void addUserToRole(final User user, final Role role); @RunAsSystem @Override void removeMembership(final RoleMembership roleMembership); @RunAsSystem @Override void updateMembership(RoleMembership roleMembership, Role newRole); @RunAsSystem @Override Collection<RoleMembership> getMemberships(Collection<Role> roles); }### Answer:
@Test void testUpdateMembership() { when(roleMembership.getId()).thenReturn("membershipId"); when(dataService.findOneById(ROLE_MEMBERSHIP, "membershipId", RoleMembership.class)) .thenReturn(roleMembership); roleMembershipService.updateMembership(roleMembership, editor); verify(roleMembership).setRole(editor); verify(dataService).update(ROLE_MEMBERSHIP, roleMembership); }
@Test void testUpdateMembershipNotAMember() { when(roleMembership.getId()).thenReturn("membershipId"); when(dataService.findOneById(ROLE_MEMBERSHIP, "membershipId", RoleMembership.class)) .thenReturn(null); assertThrows( UnknownEntityException.class, () -> roleMembershipService.updateMembership(roleMembership, editor)); }
|
### Question:
RoleRepositoryDecoratorFactory extends AbstractSystemRepositoryDecoratorFactory<Role, RoleMetadata> { @Override public Repository<Role> createDecoratedRepository(Repository<Role> repository) { return new RoleRepositoryDecorator(repository, cachedRoleHierarchy); } RoleRepositoryDecoratorFactory(
RoleMetadata roleMetadata, CachedRoleHierarchy cachedRoleHierarchy); @Override Repository<Role> createDecoratedRepository(Repository<Role> repository); }### Answer:
@Test void createDecoratedRepository() { @SuppressWarnings("unchecked") Repository<Role> repository = mock(Repository.class); EntityType entityType = mock(EntityType.class); when(repository.getEntityType()).thenReturn(entityType); Repository<Role> decoratedRepository = roleRepositoryDecoratorFactory.createDecoratedRepository(repository); assertEquals(entityType, decoratedRepository.getEntityType()); }
|
### Question:
UserRepositoryValidationDecorator extends AbstractRepositoryDecorator<User> { @Override public void add(User user) { validateAddUser(user); super.add(user); } UserRepositoryValidationDecorator(
Repository<User> delegateRepository, UserValidator userValidator); @Override void add(User user); @Override Integer add(Stream<User> userStream); @Override void update(User user); @Override void update(Stream<User> userStream); }### Answer:
@Test void testAdd() { User user = mock(User.class); userRepositoryValidationDecorator.add(user); verify(userValidator).validate(user); }
@SuppressWarnings("unchecked") @Test void testAddStream() { User user = mock(User.class); when(delegateRepository.add(any(Stream.class))) .thenAnswer( invocation -> Long.valueOf(((Stream<User>) invocation.getArgument(0)).count()).intValue()); userRepositoryValidationDecorator.add(Stream.of(user)); verify(userValidator).validate(user); }
|
### Question:
UserRepositoryValidationDecorator extends AbstractRepositoryDecorator<User> { @Override public void update(User user) { validateUpdateUser(user); super.update(user); } UserRepositoryValidationDecorator(
Repository<User> delegateRepository, UserValidator userValidator); @Override void add(User user); @Override Integer add(Stream<User> userStream); @Override void update(User user); @Override void update(Stream<User> userStream); }### Answer:
@Test void testUpdate() { String userId = "MyUserId"; User user = mock(User.class); when(user.getId()).thenReturn(userId); User existingUser = mock(User.class); when(delegateRepository.findOneById(userId)).thenReturn(existingUser); userRepositoryValidationDecorator.update(user); verify(userValidator).validate(existingUser, user); }
@SuppressWarnings({"unchecked", "ResultOfMethodCallIgnored"}) @Test void testUpdateStream() { String userId = "MyUserId"; User user = mock(User.class); when(user.getId()).thenReturn(userId); User existingUser = mock(User.class); when(delegateRepository.findOneById(userId)).thenReturn(existingUser); doAnswer( invocation -> { ((Stream<User>) invocation.getArgument(0)).count(); return null; }) .when(delegateRepository) .update(any(Stream.class)); userRepositoryValidationDecorator.update(Stream.of(user)); verify(userValidator).validate(existingUser, user); }
|
### Question:
GroupFactory extends AbstractSystemEntityFactory<Group, GroupMetadata, String> { public Group create(GroupValue groupValue) { Group group = create(); group.setName(groupValue.getName()); group.setLabel(groupValue.getLabel()); group.setDescription(groupValue.getDescription()); group.setPublic(groupValue.isPublic()); return group; } GroupFactory(GroupMetadata groupMetadata, EntityPopulator entityPopulator); Group create(GroupValue groupValue); }### Answer:
@Override @Test public void testCreate() { super.testCreate(factory, Group.class); }
|
### Question:
RoleRepositoryDecorator extends AbstractRepositoryDecorator<Role> { @Override public void update(Role role) { validateInclusion(role); clearRoleHierarchyCache(); super.update(role); } RoleRepositoryDecorator(
Repository<Role> delegateRepository, CachedRoleHierarchy cachedRoleHierarchy); @Override void add(Role role); @Override Integer add(Stream<Role> roleStream); @Override void update(Role role); @Override void update(Stream<Role> roleStream); @Override void deleteAll(); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void delete(Role role); @Override void delete(Stream<Role> roleStream); }### Answer:
@Test void testUpdateRole() { Role role = mock(Role.class); roleRepositoryDecorator.update(role); verify(cachedRoleHierarchy).markRoleHierarchyCacheDirty(); verify(delegateRepository).update(role); }
@Test void testUpdateRoleCircularHierarchy() { Role role = mockRoleWithCircularHierarchy(); assertThrows(CircularRoleHierarchyException.class, () -> roleRepositoryDecorator.update(role)); }
@Test void testUpdateRoleStream() { Role role = mock(Role.class); roleRepositoryDecorator.update(Stream.of(role)); verify(cachedRoleHierarchy).markRoleHierarchyCacheDirty(); @SuppressWarnings("unchecked") ArgumentCaptor<Stream<Role>> roleStreamCaptor = ArgumentCaptor.forClass(Stream.class); verify(delegateRepository).update(roleStreamCaptor.capture()); assertEquals(roleStreamCaptor.getValue().collect(toList()), singletonList(role)); }
|
### Question:
RoleRepositoryDecorator extends AbstractRepositoryDecorator<Role> { @Override public void deleteAll() { clearRoleHierarchyCache(); super.deleteAll(); } RoleRepositoryDecorator(
Repository<Role> delegateRepository, CachedRoleHierarchy cachedRoleHierarchy); @Override void add(Role role); @Override Integer add(Stream<Role> roleStream); @Override void update(Role role); @Override void update(Stream<Role> roleStream); @Override void deleteAll(); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void delete(Role role); @Override void delete(Stream<Role> roleStream); }### Answer:
@Test void testDeleteAllStream() { Object roleId = mock(Role.class); roleRepositoryDecorator.deleteAll(Stream.of(roleId)); verify(cachedRoleHierarchy).markRoleHierarchyCacheDirty(); @SuppressWarnings("unchecked") ArgumentCaptor<Stream<Object>> roleStreamCaptor = ArgumentCaptor.forClass(Stream.class); verify(delegateRepository).deleteAll(roleStreamCaptor.capture()); assertEquals(roleStreamCaptor.getValue().collect(toList()), singletonList(roleId)); }
@Test void testDeleteAll() { roleRepositoryDecorator.deleteAll(); verify(cachedRoleHierarchy).markRoleHierarchyCacheDirty(); verify(delegateRepository).deleteAll(); }
|
### Question:
RoleRepositoryDecorator extends AbstractRepositoryDecorator<Role> { @Override public void deleteById(Object id) { clearRoleHierarchyCache(); super.deleteById(id); } RoleRepositoryDecorator(
Repository<Role> delegateRepository, CachedRoleHierarchy cachedRoleHierarchy); @Override void add(Role role); @Override Integer add(Stream<Role> roleStream); @Override void update(Role role); @Override void update(Stream<Role> roleStream); @Override void deleteAll(); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void delete(Role role); @Override void delete(Stream<Role> roleStream); }### Answer:
@Test void testDeleteById() { Object roleId = mock(Role.class); roleRepositoryDecorator.deleteById(roleId); verify(cachedRoleHierarchy).markRoleHierarchyCacheDirty(); verify(delegateRepository).deleteById(roleId); }
|
### Question:
RoleRepositoryDecorator extends AbstractRepositoryDecorator<Role> { @Override public void delete(Role role) { clearRoleHierarchyCache(); super.delete(role); } RoleRepositoryDecorator(
Repository<Role> delegateRepository, CachedRoleHierarchy cachedRoleHierarchy); @Override void add(Role role); @Override Integer add(Stream<Role> roleStream); @Override void update(Role role); @Override void update(Stream<Role> roleStream); @Override void deleteAll(); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void delete(Role role); @Override void delete(Stream<Role> roleStream); }### Answer:
@Test void testDeleteRole() { Role role = mock(Role.class); roleRepositoryDecorator.delete(role); verify(cachedRoleHierarchy).markRoleHierarchyCacheDirty(); verify(delegateRepository).delete(role); }
@Test void testDeleteRoleStream() { Role role = mock(Role.class); roleRepositoryDecorator.delete(Stream.of(role)); verify(cachedRoleHierarchy).markRoleHierarchyCacheDirty(); @SuppressWarnings("unchecked") ArgumentCaptor<Stream<Role>> roleStreamCaptor = ArgumentCaptor.forClass(Stream.class); verify(delegateRepository).delete(roleStreamCaptor.capture()); assertEquals(roleStreamCaptor.getValue().collect(toList()), singletonList(role)); }
|
### Question:
RoleMembershipDecorator extends AbstractRepositoryDecorator<RoleMembership> { @Override public void add(RoleMembership roleMembership) { preAdd(roleMembership); super.add(roleMembership); } RoleMembershipDecorator(
Repository<RoleMembership> delegateRepository,
RoleMembershipValidator roleMembershipValidator,
SessionSecurityContextUpdater securityContextUpdater); @Override void add(RoleMembership roleMembership); @Override Integer add(Stream<RoleMembership> roleMembershipStream); @Override void update(RoleMembership roleMembership); @Override void update(Stream<RoleMembership> roleMembershipStream); @Override void delete(RoleMembership roleMembership); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<RoleMembership> roleMembershipStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testAdd() { User user = mock(User.class); RoleMembership roleMembership = mock(RoleMembership.class); when(roleMembership.getUser()).thenReturn(user); roleMembershipDecorator.add(roleMembership); verify(roleMembershipValidator).validate(roleMembership); verify(sessionSecurityContextUpdater).resetAuthorities(user); }
@SuppressWarnings("unchecked") @Test void testAddStream() { User user = mock(User.class); RoleMembership roleMembership = mock(RoleMembership.class); when(roleMembership.getUser()).thenReturn(user); when(delegateRepository.add(any(Stream.class))) .thenAnswer( invocation -> Long.valueOf(((Stream<RoleMembership>) invocation.getArgument(0)).count()) .intValue()); roleMembershipDecorator.add(Stream.of(roleMembership)); verify(roleMembershipValidator).validate(roleMembership); verify(sessionSecurityContextUpdater).resetAuthorities(user); }
|
### Question:
RoleMembershipDecorator extends AbstractRepositoryDecorator<RoleMembership> { @Override public void delete(RoleMembership roleMembership) { preDelete(roleMembership); super.delete(roleMembership); } RoleMembershipDecorator(
Repository<RoleMembership> delegateRepository,
RoleMembershipValidator roleMembershipValidator,
SessionSecurityContextUpdater securityContextUpdater); @Override void add(RoleMembership roleMembership); @Override Integer add(Stream<RoleMembership> roleMembershipStream); @Override void update(RoleMembership roleMembership); @Override void update(Stream<RoleMembership> roleMembershipStream); @Override void delete(RoleMembership roleMembership); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<RoleMembership> roleMembershipStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDelete() { User user = mock(User.class); RoleMembership roleMembership = mock(RoleMembership.class); when(roleMembership.getUser()).thenReturn(user); roleMembershipDecorator.delete(roleMembership); verify(sessionSecurityContextUpdater).resetAuthorities(user); }
@SuppressWarnings("unchecked") @Test void testDeleteStream() { User user = mock(User.class); RoleMembership roleMembership = mock(RoleMembership.class); when(roleMembership.getUser()).thenReturn(user); doAnswer(invocation -> ((Stream<?>) invocation.getArguments()[0]).count()) .when(delegateRepository) .delete(any(Stream.class)); roleMembershipDecorator.delete(Stream.of(roleMembership)); verify(sessionSecurityContextUpdater).resetAuthorities(user); }
|
### Question:
RoleMembershipDecorator extends AbstractRepositoryDecorator<RoleMembership> { @Override public void deleteById(Object id) { preDeleteById(id); super.deleteById(id); } RoleMembershipDecorator(
Repository<RoleMembership> delegateRepository,
RoleMembershipValidator roleMembershipValidator,
SessionSecurityContextUpdater securityContextUpdater); @Override void add(RoleMembership roleMembership); @Override Integer add(Stream<RoleMembership> roleMembershipStream); @Override void update(RoleMembership roleMembership); @Override void update(Stream<RoleMembership> roleMembershipStream); @Override void delete(RoleMembership roleMembership); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<RoleMembership> roleMembershipStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteById() { User user = mock(User.class); String roleMembershipId = "MyRoleMemberShipId"; RoleMembership roleMembership = mock(RoleMembership.class); when(roleMembership.getUser()).thenReturn(user); when(delegateRepository.findOneById(roleMembershipId)).thenReturn(roleMembership); roleMembershipDecorator.deleteById(roleMembershipId); verify(sessionSecurityContextUpdater).resetAuthorities(user); }
|
### Question:
GroupService { @Transactional public void persist(GroupValue groupValue) { Package rootPackage = packageFactory.create(groupValue.getRootPackage()); dataService.add(PACKAGE, rootPackage); } @SuppressWarnings("java:S107") GroupService(
PackageFactory packageFactory,
DataService dataService,
GroupMetadata groupMetadata,
RoleMembershipService roleMembershipService,
RoleMembershipMetadata roleMembershipMetadata,
MutableAclService aclService,
PermissionService permissionService); @Transactional void persist(GroupValue groupValue); @RunAsSystem Collection<Group> getGroups(); @RunAsSystem Group getGroup(String groupName); @RunAsSystem void addMember(final Group group, final User user, final Role role); @RunAsSystem void removeMember(final Group group, final User user); @RunAsSystem void updateMemberRole(final Group group, final User member, final Role newRole); @RunAsSystem boolean isGroupNameAvailable(final GroupValue groupValue); void deleteGroup(String groupName); void updateExtendsRole(Group group, Role groupRole, Role memberRole); void removeExtendsRole(Group group, Role memberRole); void grantDefaultPermissions(GroupValue groupValue); static final String MANAGER; static final String EDITOR; static final String VIEWER; static final String AUTHORITY_MANAGER; static final String AUTHORITY_EDITOR; static final String AUTHORITY_VIEWER; static final Set<String> DEFAULT_ROLES; }### Answer:
@Test void testPersist() { when(packageFactory.create(packageValue)).thenReturn(aPackage); groupService.persist(groupValue); verify(dataService).add(PackageMetadata.PACKAGE, aPackage); }
|
### Question:
GroupService { @RunAsSystem public Collection<Group> getGroups() { return dataService.findAll(GroupMetadata.GROUP, Group.class).collect(Collectors.toList()); } @SuppressWarnings("java:S107") GroupService(
PackageFactory packageFactory,
DataService dataService,
GroupMetadata groupMetadata,
RoleMembershipService roleMembershipService,
RoleMembershipMetadata roleMembershipMetadata,
MutableAclService aclService,
PermissionService permissionService); @Transactional void persist(GroupValue groupValue); @RunAsSystem Collection<Group> getGroups(); @RunAsSystem Group getGroup(String groupName); @RunAsSystem void addMember(final Group group, final User user, final Role role); @RunAsSystem void removeMember(final Group group, final User user); @RunAsSystem void updateMemberRole(final Group group, final User member, final Role newRole); @RunAsSystem boolean isGroupNameAvailable(final GroupValue groupValue); void deleteGroup(String groupName); void updateExtendsRole(Group group, Role groupRole, Role memberRole); void removeExtendsRole(Group group, Role memberRole); void grantDefaultPermissions(GroupValue groupValue); static final String MANAGER; static final String EDITOR; static final String VIEWER; static final String AUTHORITY_MANAGER; static final String AUTHORITY_EDITOR; static final String AUTHORITY_VIEWER; static final Set<String> DEFAULT_ROLES; }### Answer:
@Test void testGetGroups() { when(dataService.findAll(GROUP, Group.class)).thenReturn(Stream.of(group)); assertEquals(singletonList(group), groupService.getGroups()); }
|
### Question:
GroupService { public void deleteGroup(String groupName) { Group group = dataService .query(GroupMetadata.GROUP, Group.class) .eq(GroupMetadata.NAME, groupName) .findOne(); if (group == null) { throw new UnknownEntityException( groupMetadata, groupMetadata.getAttribute(GroupMetadata.NAME), groupName); } dataService.delete(PACKAGE, group.getRootPackage()); } @SuppressWarnings("java:S107") GroupService(
PackageFactory packageFactory,
DataService dataService,
GroupMetadata groupMetadata,
RoleMembershipService roleMembershipService,
RoleMembershipMetadata roleMembershipMetadata,
MutableAclService aclService,
PermissionService permissionService); @Transactional void persist(GroupValue groupValue); @RunAsSystem Collection<Group> getGroups(); @RunAsSystem Group getGroup(String groupName); @RunAsSystem void addMember(final Group group, final User user, final Role role); @RunAsSystem void removeMember(final Group group, final User user); @RunAsSystem void updateMemberRole(final Group group, final User member, final Role newRole); @RunAsSystem boolean isGroupNameAvailable(final GroupValue groupValue); void deleteGroup(String groupName); void updateExtendsRole(Group group, Role groupRole, Role memberRole); void removeExtendsRole(Group group, Role memberRole); void grantDefaultPermissions(GroupValue groupValue); static final String MANAGER; static final String EDITOR; static final String VIEWER; static final String AUTHORITY_MANAGER; static final String AUTHORITY_EDITOR; static final String AUTHORITY_VIEWER; static final Set<String> DEFAULT_ROLES; }### Answer:
@Test void deleteGroupTest() { @SuppressWarnings("unchecked") Query<Group> query = mock(Query.class, RETURNS_SELF); when(dataService.query(GroupMetadata.GROUP, Group.class)).thenReturn(query); when(query.eq(GroupMetadata.NAME, "devs").findOne()).thenReturn(group); groupService.deleteGroup("devs"); verify(dataService).delete(PackageMetadata.PACKAGE, group.getRootPackage()); }
|
### Question:
UserLocaleResolverImpl implements UserLocaleResolver { @Transactional(readOnly = true) @Override public Locale resolveLocale(String username) { User user = userService.getUser(username); if (user == null) { throw new UnknownUserException(username); } String languageCode = user.getLanguageCode(); Locale locale; if (languageCode != null) { locale = Locale.forLanguageTag(languageCode); } else { locale = fallbackLocaleSupplier.get(); } return locale; } UserLocaleResolverImpl(UserService userService, FallbackLocaleSupplier fallbackLocaleSupplier); @Transactional(readOnly = true) @Override Locale resolveLocale(String username); }### Answer:
@Test void testResolveLocale() { String username = "MyUsername"; String languageCode = "nl"; User user = when(mock(User.class).getLanguageCode()).thenReturn(languageCode).getMock(); when(userService.getUser(username)).thenReturn(user); assertEquals(forLanguageTag(languageCode), userLocaleResolver.resolveLocale(username)); }
@Test void testResolveLocaleUserWithoutLanguagecode() { String username = "MyUsername"; String languageCode = "nl"; User user = mock(User.class); when(userService.getUser(username)).thenReturn(user); when(fallbackLocaleSupplier.get()).thenReturn(Locale.forLanguageTag(languageCode)); assertEquals(forLanguageTag(languageCode), userLocaleResolver.resolveLocale(username)); }
@Test void testResolveLocaleUnknownUser() { String username = "MyUsername"; assertThrows(UnknownUserException.class, () -> userLocaleResolver.resolveLocale(username)); }
|
### Question:
Token extends StaticEntity { public boolean isExpired() { Optional<Instant> expirationDate = getExpirationDate(); return expirationDate.isPresent() && expirationDate.get().isBefore(now()); } Token(Entity entity); Token(EntityType entityType); Token(String id, EntityType entityType); String getId(); void setId(String id); User getUser(); void setUser(User user); String getToken(); void setToken(String token); Optional<Instant> getExpirationDate(); void setExpirationDate(Instant expirationDate); Instant getCreationDate(); void setCreationDate(Instant creationDate); @Nullable @CheckForNull String getDescription(); void setDescription(String description); boolean isExpired(); }### Answer:
@Test void testIsExpiredNoExpirationDate() { assertFalse(token.isExpired()); }
|
### Question:
UserRepositoryDecorator extends AbstractRepositoryDecorator<User> { UserRepositoryDecorator(Repository<User> delegateRepository, PasswordEncoder passwordEncoder) { super(delegateRepository); this.passwordEncoder = requireNonNull(passwordEncoder); } UserRepositoryDecorator(Repository<User> delegateRepository, PasswordEncoder passwordEncoder); @Override void add(User entity); @Override void update(User entity); @Override Integer add(Stream<User> entities); @Override void update(Stream<User> entities); @Override void delete(User entity); @Override void delete(Stream<User> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); }### Answer:
@Test void testUserRepositoryDecorator() { assertThrows(NullPointerException.class, () -> new UserRepositoryDecorator(null, null)); }
|
### Question:
UserRepositoryDecorator extends AbstractRepositoryDecorator<User> { @Override public void add(User entity) { encodePassword(entity); delegate().add(entity); } UserRepositoryDecorator(Repository<User> delegateRepository, PasswordEncoder passwordEncoder); @Override void add(User entity); @Override void update(User entity); @Override Integer add(Stream<User> entities); @Override void update(Stream<User> entities); @Override void delete(User entity); @Override void delete(Stream<User> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); }### Answer:
@Test void addEntity() { String password = "password"; User user = mock(User.class); when(user.getPassword()).thenReturn(password); userRepositoryDecorator.add(user); verify(passwordEncoder).encode(password); verify(delegateRepository).add(user); }
@SuppressWarnings("unchecked") @Test void addStream() { String password = "password"; User user0 = mock(User.class); when(user0.getPassword()).thenReturn(password); User user1 = mock(User.class); when(user1.getPassword()).thenReturn(password); when(delegateRepository.add(any(Stream.class))) .thenAnswer( invocation -> { Stream<Entity> entities = (Stream<Entity>) invocation.getArguments()[0]; List<Entity> entitiesList = entities.collect(toList()); return entitiesList.size(); }); assertEquals(valueOf(2), userRepositoryDecorator.add(of(user0, user1))); verify(passwordEncoder, times(2)).encode(password); }
|
### Question:
UserRepositoryDecorator extends AbstractRepositoryDecorator<User> { @Override public void delete(User entity) { throw new UnsupportedOperationException(DELETE_USER_MSG); } UserRepositoryDecorator(Repository<User> delegateRepository, PasswordEncoder passwordEncoder); @Override void add(User entity); @Override void update(User entity); @Override Integer add(Stream<User> entities); @Override void update(Stream<User> entities); @Override void delete(User entity); @Override void delete(Stream<User> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); }### Answer:
@Test void delete() { User user = mock(User.class); Exception exception = assertThrows( UnsupportedOperationException.class, () -> userRepositoryDecorator.delete(user)); assertThat(exception.getMessage()).containsPattern(DELETE_USER_MSG); }
@Test void deleteStream() { User user = mock(User.class); Stream<User> entities = Stream.of(user); Exception exception = assertThrows( UnsupportedOperationException.class, () -> userRepositoryDecorator.delete(entities)); assertThat(exception.getMessage()).containsPattern(DELETE_USER_MSG); }
|
### Question:
UserRepositoryDecorator extends AbstractRepositoryDecorator<User> { @Override public void deleteById(Object id) { throw new UnsupportedOperationException(DELETE_USER_MSG); } UserRepositoryDecorator(Repository<User> delegateRepository, PasswordEncoder passwordEncoder); @Override void add(User entity); @Override void update(User entity); @Override Integer add(Stream<User> entities); @Override void update(Stream<User> entities); @Override void delete(User entity); @Override void delete(Stream<User> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); }### Answer:
@Test void deleteById() { User user = mock(User.class); Exception exception = assertThrows( UnsupportedOperationException.class, () -> userRepositoryDecorator.delete(user)); assertThat(exception.getMessage()).containsPattern(DELETE_USER_MSG); }
|
### Question:
UserRepositoryDecorator extends AbstractRepositoryDecorator<User> { @Override public void deleteAll(Stream<Object> ids) { throw new UnsupportedOperationException(DELETE_USER_MSG); } UserRepositoryDecorator(Repository<User> delegateRepository, PasswordEncoder passwordEncoder); @Override void add(User entity); @Override void update(User entity); @Override Integer add(Stream<User> entities); @Override void update(Stream<User> entities); @Override void delete(User entity); @Override void delete(Stream<User> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); }### Answer:
@Test void deleteAllStream() { Exception exception = assertThrows( UnsupportedOperationException.class, () -> userRepositoryDecorator.deleteAll(Stream.of("1"))); assertThat(exception.getMessage()).containsPattern(DELETE_USER_MSG); }
@Test void deleteAll() { Exception exception = assertThrows( UnsupportedOperationException.class, () -> userRepositoryDecorator.deleteAll()); assertThat(exception.getMessage()).containsPattern(DELETE_USER_MSG); }
|
### Question:
GroupPackageRepositoryDecorator extends AbstractRepositoryDecorator<Package> { @Override public void add(Package aPackage) { super.add(aPackage); if (isGroupPackage(aPackage)) { groupPackageService.createGroup(aPackage); } } GroupPackageRepositoryDecorator(
Repository<Package> delegateRepository, GroupPackageService groupPackageService); @Override void add(Package aPackage); @Override Integer add(Stream<Package> packageStream); @Override void update(Package aPackage); @Override void update(Stream<Package> packageStream); @Override void delete(Package aPackage); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<Package> packages); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testAdd() { Package groupPackage = mockGroupPackage("group"); groupPackageRepositoryDecorator.add(groupPackage); assertAll( () -> verify(delegateRepository).add(groupPackage), () -> verify(groupPackageService).createGroup(groupPackage)); }
@Test void testAddNonGroupPackage() { Package nonGroupPackage = mockNonGroupPackage(); groupPackageRepositoryDecorator.add(nonGroupPackage); assertAll( () -> verify(delegateRepository).add(nonGroupPackage), () -> verifyNoInteractions(groupPackageService)); }
@SuppressWarnings("unchecked") @Test void testAddStream() { Package groupPackage = mockGroupPackage("test"); Package nonGroupPackage = mockNonGroupPackage(); Stream<Package> packages = Stream.of(groupPackage, nonGroupPackage); groupPackageRepositoryDecorator.add(packages); ArgumentCaptor<Stream<Package>> streamCaptor = ArgumentCaptor.forClass(Stream.class); assertAll( () -> verify(delegateRepository).add(streamCaptor.capture()), () -> assertEquals( asList(groupPackage, nonGroupPackage), streamCaptor.getValue().collect(Collectors.toList())), () -> verify(groupPackageService).createGroups(singletonList(groupPackage)), () -> verifyNoMoreInteractions(groupPackageService)); }
|
### Question:
GroupPackageRepositoryDecorator extends AbstractRepositoryDecorator<Package> { @Override public void delete(Package aPackage) { if (isGroupPackage(aPackage)) { groupPackageService.deleteGroup(aPackage); } super.delete(aPackage); } GroupPackageRepositoryDecorator(
Repository<Package> delegateRepository, GroupPackageService groupPackageService); @Override void add(Package aPackage); @Override Integer add(Stream<Package> packageStream); @Override void update(Package aPackage); @Override void update(Stream<Package> packageStream); @Override void delete(Package aPackage); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<Package> packages); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void delete() { Package groupPackage = mockGroupPackage("test"); groupPackageRepositoryDecorator.delete(groupPackage); assertAll( () -> verify(groupPackageService).deleteGroup(groupPackage), () -> verify(delegateRepository).delete(groupPackage)); }
@Test void deleteNonGroupPackage() { Package groupPackage = mockNonGroupPackage(); groupPackageRepositoryDecorator.delete(groupPackage); assertAll( () -> verifyNoInteractions(groupPackageService), () -> verify(delegateRepository).delete(groupPackage)); }
@SuppressWarnings("unchecked") @Test void deleteStream() { Package groupPackage = mockGroupPackage("group"); Package nonGroupPackage = mockNonGroupPackage(); Stream<Package> packages = Stream.of(groupPackage, nonGroupPackage); groupPackageRepositoryDecorator.delete(packages); ArgumentCaptor<Stream<Package>> streamCaptor = ArgumentCaptor.forClass(Stream.class); assertAll( () -> verify(delegateRepository).delete(streamCaptor.capture()), () -> assertEquals( asList(groupPackage, nonGroupPackage), streamCaptor.getValue().collect(Collectors.toList())), () -> verify(groupPackageService).deleteGroup(groupPackage), () -> verifyNoMoreInteractions(groupPackageService)); }
|
### Question:
GroupPackageRepositoryDecorator extends AbstractRepositoryDecorator<Package> { @Override public void deleteById(Object id) { Package aPackage = getPackage(id); if (isGroupPackage(aPackage)) { groupPackageService.deleteGroup(aPackage); } super.delete(aPackage); } GroupPackageRepositoryDecorator(
Repository<Package> delegateRepository, GroupPackageService groupPackageService); @Override void add(Package aPackage); @Override Integer add(Stream<Package> packageStream); @Override void update(Package aPackage); @Override void update(Stream<Package> packageStream); @Override void delete(Package aPackage); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<Package> packages); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void deleteById() { Package groupPackage = mockGroupPackage("test"); when(delegateRepository.findOneById("test")).thenReturn(groupPackage); groupPackageRepositoryDecorator.deleteById("test"); assertAll( () -> verify(groupPackageService).deleteGroup(groupPackage), () -> verify(delegateRepository).findOneById("test"), () -> verify(delegateRepository).delete(groupPackage)); }
|
### Question:
QueryUtils { public static boolean isTaggedType(Attribute attribute, IRI typeIRI) { return stream(attribute.getTags()).anyMatch(tag -> tag.equals(TYPE, typeIRI)); } private QueryUtils(); static boolean containsOperator(Query<Entity> q, Operator operator); static boolean containsAnyOperator(Query<Entity> q, Set<Operator> operators); static boolean containsAnyOperator(List<QueryRule> rules, Set<Operator> operators); static boolean containsComputedAttribute(Query<Entity> query, EntityType entityType); static boolean containsComputedAttribute(Sort sort, EntityType entityType); static boolean containsComputedAttribute(
Iterable<QueryRule> rules, EntityType entityType); static boolean containsNestedQueryRuleField(Query<Entity> q); static Attribute getQueryRuleAttribute(QueryRule queryRule, EntityType entityType); static List<Attribute> getAttributePath(String queryRuleField, EntityType entityType); static List<Attribute> getAttributePathExpanded(
String queryRuleField, EntityType entityType); static List<Attribute> getAttributePathExpanded(
String queryRuleField, EntityType entityType, boolean expandLabelInsteadOfId); static boolean isTaggedType(Attribute attribute, IRI typeIRI); }### Answer:
@Test public void testIsTaggedTypeTrue() { when(attribute.getTags()).thenReturn(List.of(tag)); when(tag.equals(RDF.TYPE, FOAF.PERSON)).thenReturn(true); assertTrue(QueryUtils.isTaggedType(attribute, FOAF.PERSON)); }
@Test public void testIsTaggedTypeFalse() { when(attribute.getTags()).thenReturn(List.of(tag)); assertFalse(QueryUtils.isTaggedType(attribute, FOAF.PERSON)); verify(tag).equals(RDF.TYPE, FOAF.PERSON); }
|
### Question:
RoleFactory extends AbstractSystemEntityFactory<Role, RoleMetadata, String> { public Role create(RoleValue roleValue) { Role result = create(); result.setName(roleValue.getName()); result.setLabel(roleValue.getLabel()); result.setDescription(roleValue.getDescription()); return result; } RoleFactory(RoleMetadata roleMetadata, EntityPopulator entityPopulator); Role create(RoleValue roleValue); }### Answer:
@Override @Test public void testCreate() { super.testCreate(factory, Role.class); }
|
### Question:
DataConverter { @Nullable @CheckForNull public static Integer toInt(@Nullable @CheckForNull Object source) { if (source == null) { return null; } if (source instanceof Integer) { return (Integer) source; } return convert(source, Integer.class); } private DataConverter(); static Object convert(Object source, Attribute attr); @Nullable @CheckForNull static String toString(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Integer toInt(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Long toLong(@Nullable @CheckForNull Object source); @SuppressWarnings("java:S2447") // null is a valid return value @Nullable @CheckForNull static Boolean toBoolean(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Double toDouble(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static LocalDate toLocalDate(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Instant toInstant(@Nullable @CheckForNull Object source); static List<String> toList(@Nullable @CheckForNull Object source); static void setConversionService(ConversionService conversionService); }### Answer:
@Test void testToIntNull() { assertNull(DataConverter.toInt(null)); }
@Test void testToIntInteger() { assertEquals(valueOf(123), toInt(123)); }
@Test void testToIntString() { assertEquals(valueOf(123), toInt("123")); }
|
### Question:
SortConverter implements Converter<String, Sort> { @Override public Sort convert(String source) { Sort sort = new Sort(); for (String attr : source.split(",")) { Sort.Direction direction; if (attr.endsWith(ORDER_DESC_POSTFIX)) { direction = Sort.Direction.DESC; attr = attr.substring(0, attr.length() - ORDER_DESC_POSTFIX.length()); } else if (attr.endsWith(ORDER_ASC_POSTFIX)) { direction = Sort.Direction.ASC; attr = attr.substring(0, attr.length() - ORDER_ASC_POSTFIX.length()); } else { direction = Sort.Direction.ASC; } sort.on(attr, direction); } return sort; } @Override Sort convert(String source); }### Answer:
@Test void convertSingleAttrDefault() { assertEquals(new Sort().on("attr"), new SortConverter().convert("attr")); }
@Test void convertSingleAttrAsc() { assertEquals(new Sort().on("attr", ASC), new SortConverter().convert("attr:asc")); }
@Test void convertSingleAttrDesc() { assertEquals(new Sort().on("attr", DESC), new SortConverter().convert("attr:desc")); }
@Test void convertMultiAttrDefault() { assertEquals(new Sort().on("attr0").on("attr1"), new SortConverter().convert("attr0,attr1")); }
@Test void convertMultiAttrAsc() { assertEquals( new Sort().on("attr0", ASC).on("attr1", ASC), new SortConverter().convert("attr0:asc,attr1:asc")); }
@Test void convertMultiAttrDesc() { assertEquals( new Sort().on("attr0", DESC).on("attr1", DESC), new SortConverter().convert("attr0:desc,attr1:desc")); }
@Test void convertMultiAttrAscAndDesc() { assertEquals( new Sort().on("attr0", ASC).on("attr1", DESC), new SortConverter().convert("attr0:asc,attr1:desc")); }
|
### Question:
DataConverter { @Nullable @CheckForNull public static Long toLong(@Nullable @CheckForNull Object source) { if (source == null) { return null; } if (source instanceof Long) { return (Long) source; } return convert(source, Long.class); } private DataConverter(); static Object convert(Object source, Attribute attr); @Nullable @CheckForNull static String toString(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Integer toInt(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Long toLong(@Nullable @CheckForNull Object source); @SuppressWarnings("java:S2447") // null is a valid return value @Nullable @CheckForNull static Boolean toBoolean(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Double toDouble(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static LocalDate toLocalDate(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Instant toInstant(@Nullable @CheckForNull Object source); static List<String> toList(@Nullable @CheckForNull Object source); static void setConversionService(ConversionService conversionService); }### Answer:
@Test void testToLongNull() { assertNull(DataConverter.toLong(null)); }
@Test void testToLongLong() { assertEquals(Long.valueOf(123L), toLong(123L)); }
@Test void testToLongString() { assertEquals(Long.valueOf(123L), toLong("123")); }
|
### Question:
EntityManagerV3Impl implements EntityManagerV3 { @Override public Entity create(EntityType entityType) { return entityManager.create(entityType, POPULATE); } EntityManagerV3Impl(EntityManager entityManager); @Override Entity create(EntityType entityType); @Override void populate(EntityType entityType, Entity entity, Map<String, Object> requestValues); }### Answer:
@Test void testCreate() { EntityType entityType = mock(EntityType.class); entityManagerV3.create(entityType); verify(entityManager).create(entityType, CreationMode.POPULATE); }
|
### Question:
DataConverter { @SuppressWarnings("java:S2447") @Nullable @CheckForNull public static Boolean toBoolean(@Nullable @CheckForNull Object source) { if (source == null) { return null; } if (source instanceof Boolean) { return (Boolean) source; } return convert(source, Boolean.class); } private DataConverter(); static Object convert(Object source, Attribute attr); @Nullable @CheckForNull static String toString(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Integer toInt(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Long toLong(@Nullable @CheckForNull Object source); @SuppressWarnings("java:S2447") // null is a valid return value @Nullable @CheckForNull static Boolean toBoolean(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Double toDouble(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static LocalDate toLocalDate(@Nullable @CheckForNull Object source); @Nullable @CheckForNull static Instant toInstant(@Nullable @CheckForNull Object source); static List<String> toList(@Nullable @CheckForNull Object source); static void setConversionService(ConversionService conversionService); }### Answer:
@Test void testToBooleanNull() { assertNull(DataConverter.toBoolean(null)); }
@Test void testToBooleanBoolean() { assertEquals(TRUE, toBoolean(TRUE)); }
@Test void testToBooleanString() { assertEquals(TRUE, toBoolean("true")); }
|
### Question:
UriUtils { static String createEntityCollectionUriPath( ServletUriComponentsBuilder builder, String entityTypeId) { return createEntityCollectionUriComponents(builder, entityTypeId).getPath(); } private UriUtils(); }### Answer:
@Test void testCreateEntityCollectionUriPath() { String entityTypeId = "MyEntityTypeId"; assertEquals( "/myservlet/api/v2/MyEntityTypeId", createEntityCollectionUriPath(uriBuilder, entityTypeId)); }
|
### Question:
UriUtils { static String createEntityTypeMetadataUriPath( ServletUriComponentsBuilder builder, String entityTypeId) { return createEntityTypeMetadataUriComponents(builder, entityTypeId).getPath(); } private UriUtils(); }### Answer:
@Test void testCreateEntityTypeMetadataUriPath() { String entityTypeId = "MyEntityTypeId"; assertEquals( "/myservlet/api/v2/MyEntityTypeId", createEntityTypeMetadataUriPath(uriBuilder, entityTypeId)); }
|
### Question:
UriUtils { static String createEntityTypeMetadataAttributeUriPath( ServletUriComponentsBuilder builder, String entityTypeId, String attributeName) { return createEntityTypeMetadataAttributeUriComponents(builder, entityTypeId, attributeName) .getPath(); } private UriUtils(); }### Answer:
@Test void testCreateEntityTypeMetadataAttributeUriPath() { String entityTypeId = "MyEntityTypeId"; String attributeName = "MyAttribute"; assertEquals( "/myservlet/api/v2/MyEntityTypeId/meta/MyAttribute", createEntityTypeMetadataAttributeUriPath(uriBuilder, entityTypeId, attributeName)); }
|
### Question:
UriUtils { static String createEntityUriPath( ServletUriComponentsBuilder builder, String entityTypeId, Object entityId) { return createEntityUriComponents(builder, entityTypeId, entityId).getPath(); } private UriUtils(); }### Answer:
@Test void testCreateEntityUriPath() { String entityTypeId = "MyEntityTypeId"; String entityId = "MyEntityId"; assertEquals( "/myservlet/api/v2/MyEntityTypeId/MyEntityId", createEntityUriPath(uriBuilder, entityTypeId, entityId)); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.