Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
RegexUtils { public static boolean isDate(CharSequence input) { return isMatch(RegexConstants.REGEX_DATE, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }
@Test public void testIsDate() throws Exception { assertThat(isDate("2016-08-16")).isTrue(); assertThat(isDate("2016-02-29")).isTrue(); assertThat(isDate("2015-02-29")).isFalse(); assertThat(isDate("2016-8-16")).isFalse(); }
RegexUtils { public static boolean isIP(CharSequence input) { return isMatch(RegexConstants.REGEX_IP, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }
@Test public void testIsIP() throws Exception { assertThat(isIP("255.255.255.0")).isTrue(); assertThat(isIP("256.255.255.0")).isFalse(); }
RegexUtils { public static boolean isMatch(String regex, CharSequence input) { return input != null && input.length() > 0 && Pattern.matches(regex, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }
@Test public void testIsMatch() throws Exception { assertThat(isMatch("\\d?", "1")).isTrue(); assertThat(isMatch("\\d?", "a")).isFalse(); }
RegexUtils { public static List<String> getMatches(String regex, CharSequence input) { if (input == null) return null; List<String> matches = new ArrayList<>(); Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); while (matcher.find()) { matches.add(matcher.group()); } return matches; } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }
@Test public void testGetMatches() throws Exception { System.out.println(getMatches("b.*j", "blankj blankj")); System.out.println(getMatches("b.*?j", "blankj blankj")); }
RegexUtils { public static String[] getSplits(String input, String regex) { if (input == null) return null; return input.split(regex); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }
@Test public void testGetSplits() throws Exception { System.out.println(Arrays.asList(getSplits("1 2 3", " "))); }
StringUtils { public static String upperFirstLetter(String s) { if (isEmpty(s) || !Character.isLowerCase(s.charAt(0))) return s; return String.valueOf((char) (s.charAt(0) - 32)) + s.substring(1); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }
@Test public void testUpperFirstLetter() throws Exception { assertThat(upperFirstLetter("blankj")).isEqualTo("Blankj"); assertThat(upperFirstLetter("Blankj")).isEqualTo("Blankj"); assertThat(upperFirstLetter("1Blankj")).isEqualTo("1Blankj"); }
RegexUtils { public static String getReplaceFirst(String input, String regex, String replacement) { if (input == null) return null; return Pattern.compile(regex).matcher(input).replaceFirst(replacement); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }
@Test public void testGetReplace() throws Exception { System.out.println(getReplaceFirst("1 2 3", " ", ", ")); }
RegexUtils { public static String getReplaceAll(String input, String regex, String replacement) { if (input == null) return null; return Pattern.compile(regex).matcher(input).replaceAll(replacement); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }
@Test public void testGetReplaceAll() throws Exception { System.out.println(getReplaceAll("1 2 3", " ", ", ")); }
SPUtils { public String getString(String key) { return getString(key, null); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }
@Test public void testGetString() throws Exception { assertThat(spUtils.getString("stringKey")).isEqualTo("stringVal"); assertThat(spUtils.getString("stringKey1", "stringVal1")).isEqualTo("stringVal1"); assertThat(spUtils.getString("stringKey1")).isNull(); }
SPUtils { public int getInt(String key) { return getInt(key, -1); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }
@Test public void testGetInt() throws Exception { assertThat(spUtils.getInt("intKey")).isEqualTo(1); assertThat(spUtils.getInt("intKey1", 10086)).isEqualTo(10086); assertThat(spUtils.getInt("intKey1")).isEqualTo(-1); }
SPUtils { public long getLong(String key) { return getLong(key, -1L); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }
@Test public void testGetLong() throws Exception { assertThat(spUtils.getLong("longKey")).isEqualTo(1L); assertThat(spUtils.getLong("longKey1", 10086L)).isEqualTo(10086L); assertThat(spUtils.getLong("longKey1")).isEqualTo(-1L); }
SPUtils { public float getFloat(String key) { return getFloat(key, -1f); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }
@Test public void testGetFloat() throws Exception { assertThat(spUtils.getFloat("floatKey") - 1.f).isWithin(0.f); assertThat(spUtils.getFloat("floatKey1", 10086f) - 10086f).isWithin(0.f); assertThat(spUtils.getFloat("floatKey1") + 1.f).isWithin(0.f); }
SPUtils { public boolean getBoolean(String key) { return getBoolean(key, false); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }
@Test public void testGetBoolean() throws Exception { assertThat(spUtils.getBoolean("booleanKey")).isTrue(); assertThat(spUtils.getBoolean("booleanKey1", true)).isTrue(); assertThat(spUtils.getBoolean("booleanKey1")).isFalse(); }
SPUtils { public Map<String, ?> getAll() { return sp.getAll(); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }
@Test public void testGetAll() throws Exception { Map<String, ?> map = spUtils.getAll(); for (Map.Entry<String, ?> entry : map.entrySet()) { System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); } }
SPUtils { public void remove(String key) { editor.remove(key).apply(); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }
@Test public void testRemove() throws Exception { spUtils.remove("stringKey"); testGetAll(); }
SPUtils { public boolean contains(String key) { return sp.contains(key); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }
@Test public void testContains() throws Exception { assertThat(spUtils.contains("stringKey")).isTrue(); assertThat(spUtils.contains("string")).isFalse(); }
StringUtils { public static String lowerFirstLetter(String s) { if (isEmpty(s) || !Character.isUpperCase(s.charAt(0))) return s; return String.valueOf((char) (s.charAt(0) + 32)) + s.substring(1); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }
@Test public void testLowerFirstLetter() throws Exception { assertThat(lowerFirstLetter("blankj")).isEqualTo("blankj"); assertThat(lowerFirstLetter("Blankj")).isEqualTo("blankj"); assertThat(lowerFirstLetter("1blankj")).isEqualTo("1blankj"); }
SPUtils { public void clear() { editor.clear().apply(); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }
@Test public void testClear() throws Exception { spUtils.clear(); testGetAll(); }
SDCardUtils { public static boolean isSDCardEnable() { return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()); } private SDCardUtils(); static boolean isSDCardEnable(); static String getSDCardPath(); static String getDataPath(); @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2) static String getFreeSpace(); @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2) static String getSDCardInfo(); }
@Test public void testIsSDCardEnable() throws Exception { System.out.println(SDCardUtils.isSDCardEnable()); }
SDCardUtils { public static String getSDCardPath() { if (!isSDCardEnable()) return null; String cmd = "cat /proc/mounts"; Runtime run = Runtime.getRuntime(); BufferedReader bufferedReader = null; try { Process p = run.exec(cmd); bufferedReader = new BufferedReader(new InputStreamReader(new BufferedInputStream(p.getInputStream()))); String lineStr; while ((lineStr = bufferedReader.readLine()) != null) { if (lineStr.contains("sdcard") && lineStr.contains(".android_secure")) { String[] strArray = lineStr.split(" "); if (strArray.length >= 5) { return strArray[1].replace("/.android_secure", "") + File.separator; } } if (p.waitFor() != 0 && p.exitValue() == 1) { break; } } } catch (Exception e) { e.printStackTrace(); } finally { CloseUtils.closeIO(bufferedReader); } return Environment.getExternalStorageDirectory().getPath() + File.separator; } private SDCardUtils(); static boolean isSDCardEnable(); static String getSDCardPath(); static String getDataPath(); @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2) static String getFreeSpace(); @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2) static String getSDCardInfo(); }
@Test public void testGetSDCardPath() throws Exception { System.out.println(SDCardUtils.getSDCardPath()); }
FileIOUtils { public static boolean writeFileFromIS(String filePath, final InputStream is) { return writeFileFromIS(FileUtils.getFileByPath(filePath), is, false); } private FileIOUtils(); static boolean writeFileFromIS(String filePath, final InputStream is); static boolean writeFileFromIS(String filePath, final InputStream is, boolean append); static boolean writeFileFromIS(File file, final InputStream is); static boolean writeFileFromIS(File file, final InputStream is, boolean append); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes, boolean append); static boolean writeFileFromBytesByStream(File file, final byte[] bytes); static boolean writeFileFromBytesByStream(File file, final byte[] bytes, boolean append); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromString(String filePath, String content); static boolean writeFileFromString(String filePath, String content, boolean append); static boolean writeFileFromString(File file, String content); static boolean writeFileFromString(File file, String content, boolean append); static List<String> readFile2List(String filePath); static List<String> readFile2List(String filePath, String charsetName); static List<String> readFile2List(File file); static List<String> readFile2List(File file, String charsetName); static List<String> readFile2List(String filePath, int st, int end); static List<String> readFile2List(String filePath, int st, int end, String charsetName); static List<String> readFile2List(File file, int st, int end); static List<String> readFile2List(File file, int st, int end, String charsetName); static String readFile2String(String filePath); static String readFile2String(String filePath, String charsetName); static String readFile2String(File file); static String readFile2String(File file, String charsetName); static byte[] readFile2BytesByStream(String filePath); static byte[] readFile2BytesByStream(File file); static byte[] readFile2BytesByChannel(String filePath); static byte[] readFile2BytesByChannel(File file); static byte[] readFile2BytesByMap(String filePath); static byte[] readFile2BytesByMap(File file); }
@Test public void writeFileFromIS() throws Exception { }
FileIOUtils { public static boolean writeFileFromString(String filePath, String content) { return writeFileFromString(FileUtils.getFileByPath(filePath), content, false); } private FileIOUtils(); static boolean writeFileFromIS(String filePath, final InputStream is); static boolean writeFileFromIS(String filePath, final InputStream is, boolean append); static boolean writeFileFromIS(File file, final InputStream is); static boolean writeFileFromIS(File file, final InputStream is, boolean append); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes, boolean append); static boolean writeFileFromBytesByStream(File file, final byte[] bytes); static boolean writeFileFromBytesByStream(File file, final byte[] bytes, boolean append); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromString(String filePath, String content); static boolean writeFileFromString(String filePath, String content, boolean append); static boolean writeFileFromString(File file, String content); static boolean writeFileFromString(File file, String content, boolean append); static List<String> readFile2List(String filePath); static List<String> readFile2List(String filePath, String charsetName); static List<String> readFile2List(File file); static List<String> readFile2List(File file, String charsetName); static List<String> readFile2List(String filePath, int st, int end); static List<String> readFile2List(String filePath, int st, int end, String charsetName); static List<String> readFile2List(File file, int st, int end); static List<String> readFile2List(File file, int st, int end, String charsetName); static String readFile2String(String filePath); static String readFile2String(String filePath, String charsetName); static String readFile2String(File file); static String readFile2String(File file, String charsetName); static byte[] readFile2BytesByStream(String filePath); static byte[] readFile2BytesByStream(File file); static byte[] readFile2BytesByChannel(String filePath); static byte[] readFile2BytesByChannel(File file); static byte[] readFile2BytesByMap(String filePath); static byte[] readFile2BytesByMap(File file); }
@Test public void writeFileFromString() throws Exception { }
FileIOUtils { public static List<String> readFile2List(String filePath) { return readFile2List(FileUtils.getFileByPath(filePath), null); } private FileIOUtils(); static boolean writeFileFromIS(String filePath, final InputStream is); static boolean writeFileFromIS(String filePath, final InputStream is, boolean append); static boolean writeFileFromIS(File file, final InputStream is); static boolean writeFileFromIS(File file, final InputStream is, boolean append); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes, boolean append); static boolean writeFileFromBytesByStream(File file, final byte[] bytes); static boolean writeFileFromBytesByStream(File file, final byte[] bytes, boolean append); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromString(String filePath, String content); static boolean writeFileFromString(String filePath, String content, boolean append); static boolean writeFileFromString(File file, String content); static boolean writeFileFromString(File file, String content, boolean append); static List<String> readFile2List(String filePath); static List<String> readFile2List(String filePath, String charsetName); static List<String> readFile2List(File file); static List<String> readFile2List(File file, String charsetName); static List<String> readFile2List(String filePath, int st, int end); static List<String> readFile2List(String filePath, int st, int end, String charsetName); static List<String> readFile2List(File file, int st, int end); static List<String> readFile2List(File file, int st, int end, String charsetName); static String readFile2String(String filePath); static String readFile2String(String filePath, String charsetName); static String readFile2String(File file); static String readFile2String(File file, String charsetName); static byte[] readFile2BytesByStream(String filePath); static byte[] readFile2BytesByStream(File file); static byte[] readFile2BytesByChannel(String filePath); static byte[] readFile2BytesByChannel(File file); static byte[] readFile2BytesByMap(String filePath); static byte[] readFile2BytesByMap(File file); }
@Test public void readFile2List() throws Exception { }
FileIOUtils { public static String readFile2String(String filePath) { return readFile2String(FileUtils.getFileByPath(filePath), null); } private FileIOUtils(); static boolean writeFileFromIS(String filePath, final InputStream is); static boolean writeFileFromIS(String filePath, final InputStream is, boolean append); static boolean writeFileFromIS(File file, final InputStream is); static boolean writeFileFromIS(File file, final InputStream is, boolean append); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes, boolean append); static boolean writeFileFromBytesByStream(File file, final byte[] bytes); static boolean writeFileFromBytesByStream(File file, final byte[] bytes, boolean append); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromString(String filePath, String content); static boolean writeFileFromString(String filePath, String content, boolean append); static boolean writeFileFromString(File file, String content); static boolean writeFileFromString(File file, String content, boolean append); static List<String> readFile2List(String filePath); static List<String> readFile2List(String filePath, String charsetName); static List<String> readFile2List(File file); static List<String> readFile2List(File file, String charsetName); static List<String> readFile2List(String filePath, int st, int end); static List<String> readFile2List(String filePath, int st, int end, String charsetName); static List<String> readFile2List(File file, int st, int end); static List<String> readFile2List(File file, int st, int end, String charsetName); static String readFile2String(String filePath); static String readFile2String(String filePath, String charsetName); static String readFile2String(File file); static String readFile2String(File file, String charsetName); static byte[] readFile2BytesByStream(String filePath); static byte[] readFile2BytesByStream(File file); static byte[] readFile2BytesByChannel(String filePath); static byte[] readFile2BytesByChannel(File file); static byte[] readFile2BytesByMap(String filePath); static byte[] readFile2BytesByMap(File file); }
@Test public void readFile2String() throws Exception { }
EncryptUtils { public static byte[] encryptMD2(byte[] data) { return hashTemplate(data, "MD2"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptMD2() throws Exception { assertThat(encryptMD2ToString("blankj")).isEqualTo(blankjMD2); assertThat(encryptMD2ToString("blankj".getBytes())).isEqualTo(blankjMD2); assertThat(encryptMD2("blankj".getBytes())).isEqualTo(hexString2Bytes(blankjMD2)); }
EncryptUtils { public static byte[] encryptMD5(byte[] data) { return hashTemplate(data, "MD5"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptMD5() throws Exception { assertThat(encryptMD5ToString("blankj")).isEqualTo(blankjMD5); assertThat(encryptMD5ToString("blankj".getBytes())).isEqualTo(blankjMD5); assertThat(encryptMD5("blankj".getBytes())).isEqualTo(hexString2Bytes(blankjMD5)); }
EncryptUtils { public static byte[] encryptSHA1(byte[] data) { return hashTemplate(data, "SHA1"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptSHA1() throws Exception { assertThat(encryptSHA1ToString("blankj")).isEqualTo(blankjSHA1); assertThat(encryptSHA1ToString("blankj".getBytes())).isEqualTo(blankjSHA1); assertThat(encryptSHA1("blankj".getBytes())).isEqualTo(hexString2Bytes(blankjSHA1)); }
StringUtils { public static String reverse(String s) { int len = length(s); if (len <= 1) return s; int mid = len >> 1; char[] chars = s.toCharArray(); char c; for (int i = 0; i < mid; ++i) { c = chars[i]; chars[i] = chars[len - i - 1]; chars[len - i - 1] = c; } return new String(chars); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }
@Test public void testReverse() throws Exception { assertThat(reverse("blankj")).isEqualTo("jknalb"); assertThat(reverse("blank")).isEqualTo("knalb"); assertThat(reverse("测试中文")).isEqualTo("文中试测"); assertThat(reverse(null)).isNull(); }
EncryptUtils { public static byte[] encryptSHA224(byte[] data) { return hashTemplate(data, "SHA224"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptSHA224() throws Exception { assertThat(encryptSHA224ToString("blankj")).isEqualTo(blankjSHA224); assertThat(encryptSHA224ToString("blankj".getBytes())).isEqualTo(blankjSHA224); assertThat(encryptSHA224("blankj".getBytes())).isEqualTo(hexString2Bytes(blankjSHA224)); }
EncryptUtils { public static byte[] encryptSHA256(byte[] data) { return hashTemplate(data, "SHA256"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptSHA256() throws Exception { assertThat(encryptSHA256ToString("blankj")).isEqualTo(blankjSHA256); assertThat(encryptSHA256ToString("blankj".getBytes())).isEqualTo(blankjSHA256); assertThat(encryptSHA256("blankj".getBytes())).isEqualTo(hexString2Bytes(blankjSHA256)); }
EncryptUtils { public static byte[] encryptSHA384(byte[] data) { return hashTemplate(data, "SHA384"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptSHA384() throws Exception { assertThat(encryptSHA384ToString("blankj")).isEqualTo(blankjSHA384); assertThat(encryptSHA384ToString("blankj".getBytes())).isEqualTo(blankjSHA384); assertThat(encryptSHA384("blankj".getBytes())).isEqualTo(hexString2Bytes(blankjSHA384)); }
EncryptUtils { public static byte[] encryptSHA512(byte[] data) { return hashTemplate(data, "SHA512"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptSHA512() throws Exception { assertThat(encryptSHA512ToString("blankj")).isEqualTo(blankjSHA512); assertThat(encryptSHA512ToString("blankj".getBytes())).isEqualTo(blankjSHA512); assertThat(encryptSHA512("blankj".getBytes())).isEqualTo(hexString2Bytes(blankjSHA512)); }
EncryptUtils { public static byte[] encryptHmacMD5(byte[] data, byte[] key) { return hmacTemplate(data, key, "HmacMD5"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptHmacMD5() throws Exception { assertThat(encryptHmacMD5ToString("blankj", blankjHmackey)).isEqualTo(blankjHmacMD5); assertThat(encryptHmacMD5ToString("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(blankjHmacMD5); assertThat(encryptHmacMD5("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(hexString2Bytes(blankjHmacMD5)); }
EncryptUtils { public static byte[] encryptHmacSHA1(byte[] data, byte[] key) { return hmacTemplate(data, key, "HmacSHA1"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptHmacSHA1() throws Exception { assertThat(encryptHmacSHA1ToString("blankj", blankjHmackey)).isEqualTo(blankjHmacSHA1); assertThat(encryptHmacSHA1ToString("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(blankjHmacSHA1); assertThat(encryptHmacSHA1("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(hexString2Bytes(blankjHmacSHA1)); }
EncryptUtils { public static byte[] encryptHmacSHA224(byte[] data, byte[] key) { return hmacTemplate(data, key, "HmacSHA224"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptHmacSHA224() throws Exception { assertThat(encryptHmacSHA224ToString("blankj", blankjHmackey)).isEqualTo(blankjHmacSHA224); assertThat(encryptHmacSHA224ToString("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(blankjHmacSHA224); assertThat(encryptHmacSHA224("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(hexString2Bytes(blankjHmacSHA224)); }
EncryptUtils { public static byte[] encryptHmacSHA256(byte[] data, byte[] key) { return hmacTemplate(data, key, "HmacSHA256"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptHmacSHA256() throws Exception { assertThat(encryptHmacSHA256ToString("blankj", blankjHmackey)).isEqualTo(blankjHmacSHA256); assertThat(encryptHmacSHA256ToString("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(blankjHmacSHA256); assertThat(encryptHmacSHA256("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(hexString2Bytes(blankjHmacSHA256)); }
EncryptUtils { public static byte[] encryptHmacSHA384(byte[] data, byte[] key) { return hmacTemplate(data, key, "HmacSHA384"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptHmacSHA384() throws Exception { assertThat(encryptHmacSHA384ToString("blankj", blankjHmackey)).isEqualTo(blankjHmacSHA384); assertThat(encryptHmacSHA384ToString("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(blankjHmacSHA384); assertThat(encryptHmacSHA384("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(hexString2Bytes(blankjHmacSHA384)); }
EncryptUtils { public static byte[] encryptHmacSHA512(byte[] data, byte[] key) { return hmacTemplate(data, key, "HmacSHA512"); } private EncryptUtils(); static String encryptMD2ToString(String data); static String encryptMD2ToString(byte[] data); static byte[] encryptMD2(byte[] data); static String encryptMD5ToString(String data); static String encryptMD5ToString(String data, String salt); static String encryptMD5ToString(byte[] data); static String encryptMD5ToString(byte[] data, byte[] salt); static byte[] encryptMD5(byte[] data); static String encryptMD5File2String(String filePath); static byte[] encryptMD5File(String filePath); static String encryptMD5File2String(File file); static byte[] encryptMD5File(File file); static String encryptSHA1ToString(String data); static String encryptSHA1ToString(byte[] data); static byte[] encryptSHA1(byte[] data); static String encryptSHA224ToString(String data); static String encryptSHA224ToString(byte[] data); static byte[] encryptSHA224(byte[] data); static String encryptSHA256ToString(String data); static String encryptSHA256ToString(byte[] data); static byte[] encryptSHA256(byte[] data); static String encryptSHA384ToString(String data); static String encryptSHA384ToString(byte[] data); static byte[] encryptSHA384(byte[] data); static String encryptSHA512ToString(String data); static String encryptSHA512ToString(byte[] data); static byte[] encryptSHA512(byte[] data); static String encryptHmacMD5ToString(String data, String key); static String encryptHmacMD5ToString(byte[] data, byte[] key); static byte[] encryptHmacMD5(byte[] data, byte[] key); static String encryptHmacSHA1ToString(String data, String key); static String encryptHmacSHA1ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA1(byte[] data, byte[] key); static String encryptHmacSHA224ToString(String data, String key); static String encryptHmacSHA224ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA224(byte[] data, byte[] key); static String encryptHmacSHA256ToString(String data, String key); static String encryptHmacSHA256ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA256(byte[] data, byte[] key); static String encryptHmacSHA384ToString(String data, String key); static String encryptHmacSHA384ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA384(byte[] data, byte[] key); static String encryptHmacSHA512ToString(String data, String key); static String encryptHmacSHA512ToString(byte[] data, byte[] key); static byte[] encryptHmacSHA512(byte[] data, byte[] key); static byte[] encryptDES2Base64(byte[] data, byte[] key); static String encryptDES2HexString(byte[] data, byte[] key); static byte[] encryptDES(byte[] data, byte[] key); static byte[] decryptBase64DES(byte[] data, byte[] key); static byte[] decryptHexStringDES(String data, byte[] key); static byte[] decryptDES(byte[] data, byte[] key); static byte[] encrypt3DES2Base64(byte[] data, byte[] key); static String encrypt3DES2HexString(byte[] data, byte[] key); static byte[] encrypt3DES(byte[] data, byte[] key); static byte[] decryptBase64_3DES(byte[] data, byte[] key); static byte[] decryptHexString3DES(String data, byte[] key); static byte[] decrypt3DES(byte[] data, byte[] key); static byte[] encryptAES2Base64(byte[] data, byte[] key); static String encryptAES2HexString(byte[] data, byte[] key); static byte[] encryptAES(byte[] data, byte[] key); static byte[] decryptBase64AES(byte[] data, byte[] key); static byte[] decryptHexStringAES(String data, byte[] key); static byte[] decryptAES(byte[] data, byte[] key); static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt); static String DES_Transformation; static String TripleDES_Transformation; static String AES_Transformation; }
@Test public void testEncryptHmacSHA512() throws Exception { assertThat(encryptHmacSHA512ToString("blankj", blankjHmackey)).isEqualTo(blankjHmacSHA512); assertThat(encryptHmacSHA512ToString("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(blankjHmacSHA512); assertThat(encryptHmacSHA512("blankj".getBytes(), blankjHmackey.getBytes())).isEqualTo(hexString2Bytes(blankjHmacSHA512)); }
StringUtils { public static String toDBC(String s) { if (isEmpty(s)) return s; char[] chars = s.toCharArray(); for (int i = 0, len = chars.length; i < len; i++) { if (chars[i] == 12288) { chars[i] = ' '; } else if (65281 <= chars[i] && chars[i] <= 65374) { chars[i] = (char) (chars[i] - 65248); } else { chars[i] = chars[i]; } } return new String(chars); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }
@Test public void testToDBC() throws Exception { assertThat(toDBC(" ，．＆")).isEqualTo(" ,.&"); }
HistoricUserMetricServiceImpl implements HistoricUserMetricService { @Override public void addToCurrentPeriod(final Iterable<UserMetric> saved) { saved.forEach(s -> { addToTendency(s, ChronoUnit.MINUTES); addToTendency(s, ChronoUnit.HOURS); addToTendency(s, ChronoUnit.DAYS); }); } @Autowired HistoricUserMetricServiceImpl( final UserMetricsRepository userMetricsRepository, final HistoricUserMetricRepository historicUserMetricRepository ); @Override void addToCurrentPeriod(final Iterable<UserMetric> saved); @Override List<UserMetricDTO> getHistoricMetrics(final List<String> views); }
@Test public void testAddingToExistingHistoricUserMetric() { service.addToCurrentPeriod(userMetrics); service.addToCurrentPeriod(userMetrics); final HistoricUserMetric result = repository.findById( HistoricUserMetricMapper.generateId( "AWSRequestNumber", ChronoUnit.DAYS, LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS) ) ); assertEquals("AWSRequestNumber", result.getIdentifier()); assertEquals((long) result.getTimestamp(), LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS)); assertEquals(48, result.getValue(), 0.0); assertEquals(result.getHistoricType(), ChronoUnit.DAYS); } @Test public void testAddingToUnExistingHistoricUserMetric() { service.addToCurrentPeriod(userMetrics); final HistoricUserMetric result = repository.findById( HistoricUserMetricMapper.generateId( "AWSRequestNumber", ChronoUnit.DAYS, LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS) ) ); assertEquals("AWSRequestNumber", result.getIdentifier()); assertEquals((long) result.getTimestamp(), LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS)); assertEquals(24, result.getValue(), 0.0); assertEquals(result.getHistoricType(), ChronoUnit.DAYS); } @Test public void testAddWithSampleSize() { service.addToCurrentPeriod(userMetrics); final HistoricUserMetric result = repository.findById( HistoricUserMetricMapper.generateId( "AWSResponseTime", ChronoUnit.DAYS, LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS) ) ); assertEquals("AWSResponseTime", result.getIdentifier()); assertEquals((long) result.getTimestamp(), LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS)); assertEquals(250d, result.getSampleSize(), 0.0); assertEquals(3000d, result.getValue(), 0.0); assertEquals(result.getHistoricType(), ChronoUnit.DAYS); } @Test public void testAvailabilityRate() { service.addToCurrentPeriod(userMetrics); final HistoricUserMetric result = repository.findById( HistoricUserMetricMapper.generateId( "AWSAvailabilityRate", ChronoUnit.HOURS, LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.HOURS) ) ); assertEquals("AWSAvailabilityRate", result.getIdentifier()); assertEquals((long) result.getTimestamp(), LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.HOURS)); assertEquals(2, (long) result.getSampleSize()); assertEquals(175, result.getValue(), 0.0); assertEquals(result.getHistoricType(), ChronoUnit.HOURS); }
BuildEventHandler implements EventHandler { @Override public void processEvents(final List<Event> eventList, final Set<String> dashboardIds) { final List<String> ids = eventList.stream() .map(Event::getCollectionId) .map(String.class::cast) .collect(Collectors.toList()); if (ids.contains(null)) { connectionHandler.sendEventUpdateMessageToAll(EventType.BUILD); } else { final Iterable<BuildDTO> builds = buildService.getBuildsByIds(ids); final Predicate<Dashboard> filterDashboards = dashboard -> StreamSupport .stream(builds.spliterator(), false) .anyMatch(build -> { if (dashboard.getCodeRepos() == null || dashboard.getCodeRepos().isEmpty()) { return false; } if (dashboard.getTeamMembers() != null && ! dashboard.getTeamMembers().isEmpty() && ! CollectionUtils.containsAny(dashboard.getTeamMembers(), build.getCulprits())) { return false; } return dashboard.getCodeRepos().stream().anyMatch(repo -> build.getKeywords() .stream() .anyMatch(keyword -> Pattern.matches("^" + repo + "$", keyword)) ); }); eventsHelper.processEvents(dashboardIds, filterDashboards, EventType.BUILD); } } @Autowired BuildEventHandler( final ConnectionHandler connectionHandler, final BuildService buildService, final ProcessEventsHelper eventsHelper ); @Override void processEvents(final List<Event> eventList, final Set<String> dashboardIds); }
@Test public void testBuildEvents() { final Dashboard dashboard1 = new Dashboard() .setName("dashboard1") .setCodeRepos(Arrays.asList("http: final Dashboard dashboard2 = new Dashboard() .setName("dashboard2") .setCodeRepos(Arrays.asList(".*repo3.*", "http: final Dashboard dashboard3 = new Dashboard() .setName("dashboard3") .setCodeRepos(Collections.singletonList("http: final BuildDTO build = TestObjectFactory.createBuildDTO() .setKeywords(Collections.singletonList("http: final Event event = new Event().setCollectionId(build.getBuildUrl()); final Set<String> dashboardIds = new HashSet<>( Arrays.asList(dashboard1.getName(), dashboard2.getName(), dashboard3.getName()) ); when(buildService.getBuildsByIds(anyList())).thenReturn(Collections.singletonList(build)); when(dashboardService.getDashboardWithNames(anyList())) .thenReturn(Arrays.asList(dashboard1, dashboard2, dashboard3)); eventHandler.processEvents(Collections.singletonList(event), dashboardIds); verify(connectionHandler, times(0)) .sendEventUpdateMessage(EventType.BUILD, dashboard1.getName()); verify(connectionHandler, times(1)) .sendEventUpdateMessage(EventType.BUILD, dashboard2.getName()); verify(connectionHandler, times(1)) .sendEventUpdateMessage(EventType.BUILD, dashboard3.getName()); } @Test public void testBuildWithTeamMembersEvents() { final Dashboard dashboard1 = new Dashboard() .setName("dashboard1") .setCodeRepos(Arrays.asList(".*repo1.*", "http: .setTeamMembers(Collections.singletonList("Atreyu")); final Dashboard dashboard2 = new Dashboard() .setName("dashboard2") .setCodeRepos(Arrays.asList(".*repo1.*", "http: .setTeamMembers(Arrays.asList("Atreyu", "Gmork")); final BuildDTO build = TestObjectFactory.createBuildDTO() .setKeywords(Collections.singletonList("http: .setCulprits(Collections.singletonList("Gmork")); final Event event = new Event().setCollectionId(build.getBuildUrl()); final Set<String> dashboardIds = new HashSet<>(Arrays.asList(dashboard1.getName(), dashboard2.getName())); when(buildService.getBuildsByIds(anyList())).thenReturn(Collections.singletonList(build)); when(dashboardService.getDashboardWithNames(anyList())).thenReturn(Arrays.asList(dashboard1, dashboard2)); eventHandler.processEvents(Collections.singletonList(event), dashboardIds); verify(connectionHandler, times(0)) .sendEventUpdateMessage(EventType.BUILD, dashboard1.getName()); verify(connectionHandler, times(1)) .sendEventUpdateMessage(EventType.BUILD, dashboard2.getName()); }
IssueEventHandler implements EventHandler { @Override public void processEvents(final List<Event> eventList, final Set<String> dashboardIds) { final List<String> idList = eventList.stream() .map(Event::getCollectionId) .map(String.class::cast) .collect(Collectors.toList()); if (idList.contains(null)) { connectionHandler.sendEventUpdateMessageToAll(EventType.ISSUE); } else { final Iterable<Issue> issues = issueService.getIssuesById(idList); final Predicate<Dashboard> filterDashboards = dashboard -> StreamSupport.stream(issues.spliterator(), false) .anyMatch(issue -> CollectionUtils.containsAny(issue.getKeywords(), dashboard.getBoards())); eventsHelper.processEvents(dashboardIds, filterDashboards, EventType.ISSUE); } } @Autowired IssueEventHandler( final ConnectionHandler connectionHandler, final IssueService issueService, final ProcessEventsHelper eventsHelper ); @Override void processEvents(final List<Event> eventList, final Set<String> dashboardIds); }
@Test public void testDeletedEvents() { when(dashboardService.getDashboardWithNames(anyList())).thenReturn(Collections.emptyList()); eventHandler.processEvents(Collections.singletonList(new Event()), Collections.emptySet()); verify(connectionHandler, times(1)).sendEventUpdateMessageToAll(EventType.ISSUE); }
DashboardRepositoryImpl implements DashboardRepositoryCustom { @Override public List<Dashboard> getActiveDashboards() { return getDashboardsNotInStatus(DELETED, TRANSIENT); } @Override List<Dashboard> getActiveAndTransientDashboards(); @Override List<Dashboard> getActiveDashboards(); @Override void saveFile(final InputStream image, final String name); @Override InputStreamResource readFile(final String name); }
@Ignore @Test public void transientAndDeletedDashboardsAreNotReturnedTest() { final List<Dashboard> activeDashboards = dashboardRepository.getActiveDashboards(); final List<String> dashboardNames = activeDashboards .stream() .map(Dashboard::getName) .collect(Collectors.toList()); assertTrue(dashboardNames.contains("regularDashboard")); assertTrue(dashboardNames.contains("nullStatusDashboard")); assertEquals(activeDashboards.size(), 2); }
UserMetricsRepositoryImpl implements UserMetricsRepositoryCustom { @Override public List<UserMetric> findAllStartingWithViewId(final List<String> viewIds) { final Aggregation agg = newAggregation( match(getCriteriaExpressionsForUserMetrics(viewIds)) ); final AggregationResults<UserMetric> aggregationResult = mongoTemplate.aggregate(agg, UserMetric.class, UserMetric.class); return aggregationResult.getMappedResults(); } @Override List<UserMetric> findAllStartingWithViewId(final List<String> viewIds); }
@Test public void findUserMetricsByViewIdsWithoutResultsTest() { final List<String> viewIds = Collections.singletonList("aaa"); final List<UserMetric> userMetrics = userMetricsRepository.findAllStartingWithViewId(viewIds); assertEquals(Collections.emptyList(), userMetrics); } @Test public void findUserMetricsByViewIdsTest() { final List<String> viewIds1 = Collections.singletonList("AWS/123456789012"); final List<String> viewIds2 = Collections.singletonList("AWS/123456789012/alb"); final List<String> viewIds3 = Collections.singletonList("AWS/123456789012/apigateway/restapi"); final List<UserMetric> userMetrics1 = userMetricsRepository.findAllStartingWithViewId(viewIds1); final List<UserMetric> userMetrics2 = userMetricsRepository.findAllStartingWithViewId(viewIds2); final List<UserMetric> userMetrics3 = userMetricsRepository.findAllStartingWithViewId(viewIds3); assertEquals(3, userMetrics1.size()); assertEquals(2, userMetrics2.size()); assertEquals(1, userMetrics3.size()); assertTrue(userMetrics1.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/alb/alb1")); assertTrue(userMetrics1.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/alb/alb2")); assertTrue(userMetrics1.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/apigateway/restapi")); assertTrue(userMetrics2.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/alb/alb1")); assertTrue(userMetrics2.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/alb/alb2")); assertTrue(userMetrics3.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/apigateway/restapi")); } @Test public void findUserMetricsByMultipleViewIdsTest() { final List<String> viewIds = Arrays.asList("AWS/111111111111", "GCP/222222222222"); final List<UserMetric> userMetrics = userMetricsRepository.findAllStartingWithViewId(viewIds); assertEquals(2, userMetrics.size()); assertTrue(userMetrics.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/111111111111/elb/elb1")); assertTrue(userMetrics.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("GCP/222222222222/elb/elb1")); }
IssueRepositoryImpl implements IssueRepositoryCustom { @Override public List<String> programIncrementBoardFeatures( final List<String> boards, final List<String> programIncrementFeatures ) { final Aggregation agg = newAggregation( match(Criteria .where("parentsKeys").in(programIncrementFeatures) .and("keywords").in(boards) ), unwind("parentsKeys"), group() .addToSet("parentsKeys") .as("features"), project("features") .andExclude("_id") ); final AggregationResults<ProgramIncrementBoardFeatures> aggregationResult = mongoTemplate.aggregate(agg, "issue", ProgramIncrementBoardFeatures.class); return aggregationResult.getUniqueMappedResult() != null ? aggregationResult.getUniqueMappedResult().features : new ArrayList<>(); } @Override double getBacklogEstimateByKeywords(final List<String> boards); @Override SprintStats getSprintStatsByKeywords(final List<String> boards); @Override List<String> programIncrementBoardFeatures( final List<String> boards, final List<String> programIncrementFeatures ); @Override ProgramIncrementNamesAggregationResult getProductIncrementFromPiPattern(final Pattern pi); }
@Test public void testFeatureAndPIComeFromTeam() { final List<String> boardPIFeatures = issueRepository.programIncrementBoardFeatures( Collections.singletonList("mirrorgate"), Arrays.asList("issue1", "issue2") ); assertEquals(2, boardPIFeatures.size()); }
IssueRepositoryImpl implements IssueRepositoryCustom { @Override public ProgramIncrementNamesAggregationResult getProductIncrementFromPiPattern(final Pattern pi) { final Aggregation agg = newAggregation( match(Criteria .where("type").is(IssueType.FEATURE.getName()) ), project("piNames").andExclude("_id"), unwind("piNames"), match(Criteria .where("piNames").is(pi) ), group().addToSet("piNames").as("piNames") ); final AggregationResults<ProgramIncrementNamesAggregationResult> aggregationResult = mongoTemplate.aggregate(agg, "issue", ProgramIncrementNamesAggregationResult.class); return aggregationResult.getUniqueMappedResult(); } @Override double getBacklogEstimateByKeywords(final List<String> boards); @Override SprintStats getSprintStatsByKeywords(final List<String> boards); @Override List<String> programIncrementBoardFeatures( final List<String> boards, final List<String> programIncrementFeatures ); @Override ProgramIncrementNamesAggregationResult getProductIncrementFromPiPattern(final Pattern pi); }
@Test public void testAggregationWithResults() { final ProgramIncrementNamesAggregationResult piNames = issueRepository.getProductIncrementFromPiPattern( Pattern.compile("^PI.*$") ); assertEquals(piNames.getPiNames().size(), 5); assertTrue(piNames.getPiNames().contains("PI1")); assertTrue(piNames.getPiNames().contains("PI2")); assertTrue(piNames.getPiNames().contains("PI3")); assertTrue(piNames.getPiNames().contains("PI4")); assertTrue(piNames.getPiNames().contains("PI5")); } @Test public void testAggregationWithoutResults() { final ProgramIncrementNamesAggregationResult piNames = issueRepository.getProductIncrementFromPiPattern( Pattern.compile("aaa") ); assertNull(piNames); }
TokenCreator { public static MirrorgateAuthenticationToken createHeaderBasedToken(final String headerValue) { GrantedAuthority authority; if (StringUtils.isEmpty(headerValue) || headerValue.contains("COLLECTOR")) { authority = new SimpleGrantedAuthority(SecurityAuthoritiesEnum.COLLECTOR.toString()); } else { if (headerValue.contains("ANONYMOUS")) { authority = new SimpleGrantedAuthority(SecurityAuthoritiesEnum.SCREEN.toString()); } else { authority = new SimpleGrantedAuthority(SecurityAuthoritiesEnum.REGULAR.toString()); } } LOG.info("Role assigned: " + authority.getAuthority()); return new MirrorgateAuthenticationToken(headerValue, Collections.singletonList(authority)); } private TokenCreator(); static MirrorgateAuthenticationToken createHeaderBasedToken(final String headerValue); }
@Test public void testScreenUser() { final MirrorgateAuthenticationToken token = TokenCreator.createHeaderBasedToken("[email protected]"); final SimpleGrantedAuthority expectedAuthority = new SimpleGrantedAuthority( SecurityAuthoritiesEnum.REGULAR.toString() ); assertTrue(token.getCredentials().contains(expectedAuthority)); } @Test public void testEmptyHeader() { final MirrorgateAuthenticationToken token = TokenCreator.createHeaderBasedToken(""); final SimpleGrantedAuthority expectedAuthority = new SimpleGrantedAuthority( SecurityAuthoritiesEnum.COLLECTOR.toString() ); assertTrue(token.getCredentials().contains(expectedAuthority)); } @Test public void testNullHeader() { final MirrorgateAuthenticationToken token = TokenCreator.createHeaderBasedToken(null); final SimpleGrantedAuthority expectedAuthority = new SimpleGrantedAuthority( SecurityAuthoritiesEnum.COLLECTOR.toString() ); assertTrue(token.getCredentials().contains(expectedAuthority)); } @Test public void testRegularUser() { final MirrorgateAuthenticationToken token = TokenCreator.createHeaderBasedToken("ANONYMOUS"); final SimpleGrantedAuthority expectedAuthority = new SimpleGrantedAuthority( SecurityAuthoritiesEnum.SCREEN.toString() ); assertTrue(token.getCredentials().contains(expectedAuthority)); } @Test public void testCollectorUser() { final MirrorgateAuthenticationToken token = TokenCreator.createHeaderBasedToken("COLLECTOR"); final SimpleGrantedAuthority expectedAuthority = new SimpleGrantedAuthority( SecurityAuthoritiesEnum.COLLECTOR.toString() ); assertTrue(token.getCredentials().contains(expectedAuthority)); }
EventScheduler { @Scheduled(fixedDelayString = "${events.scheduler.delay.millis}") void checkEventUpdates() { LOG.debug("Processing events for timestamp {}", schedulerTimestamp); final Set<String> dashboardIds = handler.getDashboardsWithSession(); if (dashboardIds != null) { LOG.debug("Active dashboards {}", dashboardIds.size()); } if (! Objects.requireNonNull(dashboardIds).isEmpty()) { final List<Event> unprocessedEvents = eventService.getEventsSinceTimestamp(schedulerTimestamp); if (! unprocessedEvents.isEmpty()) { unprocessedEvents.stream() .collect(Collectors.groupingBy(Event::getEventType)) .forEach((key, value) -> beanFactory.getBean(key.getValue(), EventHandler.class) .processEvents(value, dashboardIds)); schedulerTimestamp = unprocessedEvents.get(unprocessedEvents.size() - 1).getTimestamp(); LOG.debug("Modified timestamp: {}", schedulerTimestamp); } } } @Autowired EventScheduler( final EventService eventService, final ConnectionHandler handler, final BeanFactory beanFactory ); @PostConstruct void initSchedulerTimestamp(); }
@Test public void testSchedulerTimestampIsModified() { when(eventService.getEventsSinceTimestamp(anyLong())) .thenReturn(Arrays.asList(createBuildEvent(), createIssueEvent())); when(eventService.getLastEvent()).thenReturn(null); when(eventsHandler.getDashboardsWithSession()).thenReturn(new HashSet<>(Collections.singletonList("123"))); eventScheduler.checkEventUpdates(); assertTrue(outputCapture.toString().contains("1234567")); }
DataServiceBase implements TableDataService { @Override public List<Map<String, String>> getPageEntries(PaginationCriteria paginationCriteria) throws TableDataException { List<T> data = getData(paginationCriteria); log.debug("Table data retrieved..."); List<Map<String, String>> records = new ArrayList<>(data.size()); try { data.forEach(i -> { Map<String, Object> m = objectMapper.convertValue(i, Map.class); records.add(m.entrySet().stream() .collect(Collectors.toMap(k -> k.getKey(), v -> v.getValue().toString()))); }); log.debug("Data map generated..."); } catch (Exception e) { log.error("Error fetching page entries.", e); throw new TableDataException("", e); } return records; } @Override List<Map<String, String>> getPageEntries(PaginationCriteria paginationCriteria); }
@Test void getPageEntries() throws TableDataException { List<Map<String, String>> data = dataService.getPageEntries(null); assertEquals(5, data.size()); assertEquals("Lisa", data.get(0).get("name")); assertEquals("2", data.get(1).get("id")); assertEquals("38", data.get(2).get("age")); }
PingResponseWriter { public void write(PrintWriter writer) { writer.write("pong"); } void write(PrintWriter writer); }
@Test public void writeResponse() throws Exception { underTest.write(printWriter); verify(printWriter).write("pong"); }
JmsMessagePropertyExtractor implements MessagePropertyExtractor { @Override public Map<String, Object> extractProperties(Message message) { if (message == null) { throw new IllegalArgumentException("Message cannot be null"); } Map<String, Object> properties = new HashMap<>(); try { for (Enumeration propertyNames = message.getPropertyNames(); propertyNames.hasMoreElements(); ) { extractPropertyFromMessage((String) propertyNames.nextElement(), message, properties); } } catch (JMSException e) { LOGGER.error("Could not read propertyNames from message '%s'", message, e); } return properties; } @Override Map<String, Object> extractProperties(Message message); }
@Test public void cannotReadPropertyNamesFromMessage() throws JMSException { when(message.getPropertyNames()).thenThrow(JMSException.class); assertThat(underTest.extractProperties(message), is(emptyMap())); } @Test public void cannotReadOnePropertyFromMessage() throws JMSException { Vector<String> propertyNames = new Vector<>(Arrays.asList("foo", "one")); when(message.getObjectProperty("foo")).thenThrow(JMSException.class); when(message.getObjectProperty("one")).thenReturn(1); when(message.getPropertyNames()).thenReturn(propertyNames.elements()); Map<String, Object> actual = underTest.extractProperties(message); assertThat(actual, hasEntry("one", 1)); } @Test public void exceptionIsThrownIfMessageIsNull() { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("Message cannot be null"); underTest.extractProperties(null); } @Test public void messageWithNoProperties() throws JMSException { when(message.getPropertyNames()).thenReturn(emptyEnumeration()); Map<String, Object> properties = underTest.extractProperties(message); assertThat(properties, equalTo(emptyMap())); } @Test public void messageWithProperties() throws Exception { Enumeration<String> messageProperties = messageProperties(Pair.of("foo", "bar"), Pair.of("one", 1)); when(message.getPropertyNames()).thenReturn(messageProperties); Map<String, Object> actual = underTest.extractProperties(message); assertThat(actual, hasEntry("foo", "bar")); assertThat(actual, hasEntry("one", 1)); }
JmsTemplateBeanDefinitionFactory { public AbstractBeanDefinition create(String connectionFactoryBeanName) { return genericBeanDefinition(JmsTemplate.class) .addConstructorArgReference(connectionFactoryBeanName) .getBeanDefinition(); } AbstractBeanDefinition create(String connectionFactoryBeanName); String createBeanName(String brokerName); static final String JMS_TEMPLATE_BEAN_NAME_PREFIX; }
@Test public void createJmsTemplateBeanDefinition() { final AbstractBeanDefinition abstractBeanDefinition = underTest.create("internal-jmsConnectionFactory"); Assert.assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(JmsTemplate.class)); Assert.assertThat(abstractBeanDefinition.getConstructorArgumentValues().getIndexedArgumentValues().size(), is(1)); Assert.assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(0, ConnectionFactory.class).getValue(), is(equalTo(new RuntimeBeanReference("internal-jmsConnectionFactory")))); }
JmsTemplateBeanDefinitionFactory { public String createBeanName(String brokerName) { return JMS_TEMPLATE_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(String connectionFactoryBeanName); String createBeanName(String brokerName); static final String JMS_TEMPLATE_BEAN_NAME_PREFIX; }
@Test public void createJmsTemplateBeanName() { assertThat(underTest.createBeanName("internal"), Matchers.is("jmsTemplate-internal")); }
SpringMessageSender implements MessageSender { @Override public void send(FailedMessage failedMessage) { LOGGER.debug("Resending FailedMessage: {}", failedMessage.getFailedMessageId()); jmsTemplate.send( failedMessage .getDestination() .getName() .orElseThrow(destinationMissingFor(failedMessage.getFailedMessageId())), failedMessageCreatorFactory.create(failedMessage) ); } @SuppressWarnings("unused") SpringMessageSender(JmsTemplate jmsTemplate); SpringMessageSender(FailedMessageCreatorFactory failedMessageCreatorFactory, JmsTemplate jmsTemplate); @Override void send(FailedMessage failedMessage); }
@Test public void successfullySendMessage() throws Exception { when(failedMessage.getDestination()).thenReturn(aDestination("some-destination")); underTest.send(failedMessage); verify(jmsTemplate).send("some-destination", failedMessageCreator); } @Test(expected = DestinationException.class) public void destinationIsMissing() { when(failedMessage.getDestination()).thenReturn(aDestination(null)); underTest.send(failedMessage); }
FailedMessageCreator implements MessageCreator { @Override public Message createMessage(Session session) throws JMSException { TextMessage textMessage = session.createTextMessage(); for (JmsMessageTransformer<TextMessage, FailedMessage> jmsMessageTransformer : jmsMessageTransformers) { jmsMessageTransformer.transform(textMessage, failedMessage); } return textMessage; } FailedMessageCreator(FailedMessage failedMessage); FailedMessageCreator(FailedMessage failedMessage, List<JmsMessageTransformer<TextMessage, FailedMessage>> jmsMessageTransformers); @Override Message createMessage(Session session); }
@Test public void createJmsMessage() throws Exception { when(session.createTextMessage()).thenReturn(textMessage); FailedMessageCreator underTest = new FailedMessageCreator(newFailedMessage() .withContent("Hello") .withProperty("foo", "bar") .build() ); assertThat(underTest.createMessage(session), Matchers.is(textMessage)); verify(textMessage).setText("Hello"); verify(textMessage).setObjectProperty("foo", "bar"); }
PropertyMatchesPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return pattern .matcher(getPropertyAsString(failedMessage)) .matches(); } PropertyMatchesPredicate(@JsonProperty("name") String name, @JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
@Test public void propertyMatchesPattern() { when(failedMessage.getProperty("foo")).thenReturn("some.property.value"); underTest = new PropertyMatchesPredicate("foo", "^some\\.property.*"); assertThat(underTest.test(failedMessage), is(true)); } @Test public void propertyDoesNotMatchPattern() { when(failedMessage.getProperty("foo")).thenReturn("some.property.value"); underTest = new PropertyMatchesPredicate("foo", "^some\\.property"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void propertyValueIsNull() { when(failedMessage.getProperty("foo")).thenReturn(null); underTest = new PropertyMatchesPredicate("foo", "^some\\.property"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void propertyIsABoolean() { when(failedMessage.getProperty("aBoolean")).thenReturn(true); underTest = new PropertyMatchesPredicate("aBoolean", "true"); assertThat(underTest.test(failedMessage), is(true)); } @Test public void propertyIsANumber() { when(failedMessage.getProperty("aNumber")).thenReturn(12345); underTest = new PropertyMatchesPredicate("aNumber", "^12345$"); assertThat(underTest.test(failedMessage), is(true)); }
FailedMessageConverter implements DocumentWithIdConverter<FailedMessage, FailedMessageId> { @Override public FailedMessage convertToObject(Document document) { if (document == null) { return null; } return newFailedMessage() .withFailedMessageId(getFailedMessageId(document)) .withJmsMessageId(getJmsMessageId(document)) .withDestination(getDestination(document)) .withSentDateTime(getSentDateTime(document)) .withFailedDateTime(getFailedDateTime(document)) .withContent(getContent(document)) .withStatusHistoryEvent(getStatusHistoryEvent(document)) .withProperties(propertiesMongoMapper.convertToObject(document.getString(PROPERTIES))) .withLabels(getLabels(document)) .build(); } FailedMessageConverter(DocumentConverter<Destination> destinationDocumentConverter, DocumentConverter<StatusHistoryEvent> statusHistoryEventDocumentConverter, ObjectConverter<Map<String, Object>, String> propertiesMongoMapper); @Override FailedMessage convertToObject(Document document); StatusHistoryEvent getStatusHistoryEvent(Document document); FailedMessageId getFailedMessageId(Document document); Destination getDestination(Document document); String getContent(Document document); Instant getFailedDateTime(Document document); Instant getSentDateTime(Document document); @Override Document convertFromObject(FailedMessage item); Document convertForUpdate(FailedMessage item); @Override Document createId(FailedMessageId failedMessageId); static final String DESTINATION; static final String SENT_DATE_TIME; static final String FAILED_DATE_TIME; static final String CONTENT; static final String PROPERTIES; static final String STATUS_HISTORY; static final String LABELS; static final String JMS_MESSAGE_ID; }
@Test public void mapNullDocumentToFailedMessage() { assertThat(underTest.convertToObject(null), is(nullValue())); }
AndPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .allMatch(p -> p.test(failedMessage)); } AndPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description describe(Description description); AndPredicate and(FailedMessagePredicate failedMessagePredicate); @Override String toString(); static AndPredicate and(FailedMessagePredicate lhs, FailedMessagePredicate rhs); }
@Test public void resultIsFalseWhen1stPredicateIsTrue2ndPredicteIsFalse() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(true); when(failedMessagePredicate2.test(failedMessage)).thenReturn(false); assertThat(underTest.test(failedMessage), is(false)); verify(failedMessagePredicate1).test(failedMessage); verify(failedMessagePredicate2).test(failedMessage); } @Test public void resultIsAlwaysFalseWhen1stPredicateIsFalse() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(false); when(failedMessagePredicate2.test(failedMessage)).thenReturn(true); assertThat(underTest.test(failedMessage), is(false)); verify(failedMessagePredicate1).test(failedMessage); verifyZeroInteractions(failedMessagePredicate2); } @Test public void resultIsTrueWhenAllPredicatesReturnTrue() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(true); when(failedMessagePredicate2.test(failedMessage)).thenReturn(true); assertThat(underTest.test(failedMessage), is(true)); verify(failedMessagePredicate1).test(failedMessage); verify(failedMessagePredicate2).test(failedMessage); }
AndPredicate implements FailedMessagePredicate { public List<FailedMessagePredicate> getPredicates() { return new ArrayList<>(predicates); } AndPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description describe(Description description); AndPredicate and(FailedMessagePredicate failedMessagePredicate); @Override String toString(); static AndPredicate and(FailedMessagePredicate lhs, FailedMessagePredicate rhs); }
@Test public void canSerialiseAndDeserialisePredicate() throws IOException { ObjectMapper objectMapper = new JacksonConfiguration().objectMapper(new InjectableValues.Std()); objectMapper.registerSubtypes(BooleanPredicate.class); final AndPredicate underTest = objectMapper.readValue( objectMapper.writeValueAsString(new AndPredicate(singletonList(alwaysTruePredicate))), AndPredicate.class ); assertThat(underTest.getPredicates(), contains(alwaysTruePredicate)); }
AndPredicate implements FailedMessagePredicate { @Override public Description describe(Description description) { Description finalDescription = description.append("( "); final Iterator<FailedMessagePredicate> iterator = predicates.iterator(); while (iterator.hasNext()) { finalDescription = iterator.next().describe(finalDescription); if (iterator.hasNext()) { finalDescription = finalDescription.append(" AND "); } } return finalDescription.append(" )"); } AndPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description describe(Description description); AndPredicate and(FailedMessagePredicate failedMessagePredicate); @Override String toString(); static AndPredicate and(FailedMessagePredicate lhs, FailedMessagePredicate rhs); }
@Test public void describeTest() { when(failedMessagePredicate1.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate1")); when(failedMessagePredicate2.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate2")); assertThat(underTest.describe(new StringDescription()).getOutput(), is("( predicate1 AND predicate2 )")); }
AndPredicate implements FailedMessagePredicate { @Override public String toString() { return describe(new StringDescription()).toString(); } AndPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description describe(Description description); AndPredicate and(FailedMessagePredicate failedMessagePredicate); @Override String toString(); static AndPredicate and(FailedMessagePredicate lhs, FailedMessagePredicate rhs); }
@Test public void toStringTest() { when(failedMessagePredicate1.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate1")); when(failedMessagePredicate2.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate2")); assertThat(underTest.toString(), is("( predicate1 AND predicate2 )")); }
PropertyEqualToPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return this.value.equals(failedMessage.getProperty(name)); } PropertyEqualToPredicate(@JsonProperty("name") String name, @JsonProperty("value") Object value); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
@Test public void propertiesMatch() { when(failedMessage.getProperty("foo")).thenReturn("bar"); assertThat(underTest.test(failedMessage), is(true)); } @Test public void propertiesDoNotMatch() { when(failedMessage.getProperty("foo")).thenReturn("rab"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void propertyDoesNotExist() { when(failedMessage.getProperty("foo")).thenReturn(null); assertThat(underTest.test(failedMessage), is(false)); }
MongoStatusHistoryQueryBuilder { public Document currentStatusEqualTo(Status status) { return new Document(STATUS_HISTORY + ".0." + STATUS, status.name()); } Document currentStatusEqualTo(Status status); Document currentStatusNotEqualTo(Status status); Document currentStatusIn(Set<Status> statuses); Document currentStatusIn(Document query, Set<Status> statuses); }
@Test public void currentStatusEqualToGivenStatus() { assertThat(underTest.currentStatusEqualTo(FAILED), hasField(STATUS_HISTORY + ".0." + STATUS, equalTo(FAILED.name()))); }
DestinationEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return destination.equals(failedMessage.getDestination().getName()); } DestinationEqualsPredicate(@JsonProperty("destination") Optional<String> destination); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
@Test public void nameOfDestinationMatches() { when(destination.getName()).thenReturn(Optional.of("some-destination")); assertThat(underTest.test(failedMessage), Matchers.is(true)); } @Test public void nameOfDestinationIsEmpty() { when(destination.getName()).thenReturn(Optional.empty()); assertThat(underTest.test(failedMessage), Matchers.is(false)); } @Test public void nameOfDestinationIDoesNotMatch() { when(destination.getName()).thenReturn(Optional.of("another-destination")); assertThat(underTest.test(failedMessage), Matchers.is(false)); }
DestinationEqualsPredicate implements FailedMessagePredicate { @Override public Description describe(Description description) { return description.append("destination ").append(destination.map(d -> "= '" + d + "'").orElse("is empty")); } DestinationEqualsPredicate(@JsonProperty("destination") Optional<String> destination); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
@Test public void describeWithAnEmptyDestination() { underTest = new DestinationEqualsPredicate(Optional.empty()); final Description<String> description = underTest.describe(new StringDescription()); assertThat(description.getOutput(), is("destination is empty")); }
PropertyExistsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return failedMessage.getProperties().containsKey(propertyName); } PropertyExistsPredicate(@JsonProperty("propertyName") String propertyName); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
@Test public void propertyExists() { when(failedMessage.getProperties()).thenReturn(Collections.singletonMap("foo", "bar")); assertThat(underTest.test(failedMessage), is(true)); } @Test public void propertyDoesNotExist() { when(failedMessage.getProperties()).thenReturn(Collections.emptyMap()); assertThat(underTest.test(failedMessage), is(false)); }
ContentEqualToPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return content.equals(failedMessage.getContent()); } ContentEqualToPredicate(@JsonProperty("content") String content); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
@Test public void contentInMessageIsNull() { when(failedMessage.getContent()).thenReturn(null); assertThat(underTest.test(failedMessage), is(false)); } @Test public void contentDoesNotMatch() { when(failedMessage.getContent()).thenReturn("bar"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void contentMatches() { when(failedMessage.getContent()).thenReturn("foo"); assertThat(underTest.test(failedMessage), is(true)); }
MongoStatusHistoryQueryBuilder { public Document currentStatusIn(Set<Status> statuses) { return currentStatusIn(new Document(), statuses); } Document currentStatusEqualTo(Status status); Document currentStatusNotEqualTo(Status status); Document currentStatusIn(Set<Status> statuses); Document currentStatusIn(Document query, Set<Status> statuses); }
@Test public void currentStatusIsOneOfTheGivenStatuses() { assertThat(underTest.currentStatusIn(immutableEnumSet(FAILED, CLASSIFIED)), hasField(STATUS_HISTORY + ".0." + STATUS, hasField(IN, contains(FAILED.name(), CLASSIFIED.name())))); } @Test public void currentStatusIsOneOfTheGivenStatusesWhenDocumentPassedIn() { Document document = new Document(); DocumentMatcher expectedDocument = hasField(STATUS_HISTORY + ".0." + STATUS, hasField(IN, contains(FAILED.name(), CLASSIFIED.name()))); Document actualDocument = underTest.currentStatusIn(document, immutableEnumSet(FAILED, CLASSIFIED)); assertThat(actualDocument, expectedDocument); assertThat(actualDocument, is(document)); }
ContentContainsJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { if (StringUtils.isNotEmpty(failedMessage.getContent())) { try { final Object object = parseContext.parse(failedMessage.getContent()).read(jsonPath); if (object instanceof JSONArray) { return !((JSONArray)object).isEmpty(); } else { return true; } } catch (PathNotFoundException e) { return false; } } return false; } ContentContainsJsonPath(@JsonProperty("jsonPath") String jsonPath); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
@Test public void searchSingleFieldThatDoesNotExist() { underTest = new ContentContainsJsonPath("$.location"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void searchSingleFieldThatDoesExist() { underTest = new ContentContainsJsonPath("$.expensive"); assertThat(underTest.test(failedMessage), is(true)); } @Test public void searchSingleFieldThatDoesExistWhereValueIsNull() { underTest = new ContentContainsJsonPath("$.store.bicycle.model"); assertThat(underTest.test(failedMessage), is(true)); } @Test public void searchArrayForFieldThatDoesExist() { underTest = new ContentContainsJsonPath("$.store.book[*].author"); assertThat(underTest.test(failedMessage), is(true)); } @Test public void searchArrayForFieldThatDoesExistWhereValuesAreNull() { underTest = new ContentContainsJsonPath("$.store.book[*].publicationDate"); assertThat(underTest.test(failedMessage), is(true)); } @Test public void searchArrayForFieldThatDoesNotExist() { underTest = new ContentContainsJsonPath("$.store.book[*].breakfast"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void messageContentIsNull() { when(failedMessage.getContent()).thenReturn(null); underTest = new ContentContainsJsonPath("$.store.expensive"); assertThat(underTest.test(failedMessage), is(false)); }
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath, @JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
@Test public void attemptToMatchSingleFieldThatDoesNotExist() { underTest = new ContentMatchesJsonPath("$.location", "true"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void attemptToMatchSingleFieldRegexDoesNotMatch() { underTest = new ContentMatchesJsonPath("$.expensive", "false"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void attemptToMatchSingleFieldValueIsNull() { underTest = new ContentMatchesJsonPath("$.store.bicycle.model", "^foo$"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void successfullyMatchSingleField() { assertThat(underTest.test(failedMessage), is(true)); } @Test public void attemptToMatchSingleValueInArrayForFieldThatDoesExist() { underTest = new ContentMatchesJsonPath("$.store.book[0].isbn", "0-553-21311-3"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void attemptToMatchSingleValueInArrayWhereValuesAreNull() { underTest = new ContentMatchesJsonPath("$.store.book[0].publicationDate", "2018-01-01"); assertThat(underTest.test(failedMessage), is(false)); } @Test public void successfullyMatchSingleValueInArray() { underTest = new ContentMatchesJsonPath("$.store.book[1].category", "fiction"); assertThat(underTest.test(failedMessage), is(true)); } @Test public void attemptToMatchAnyValueInArrayForFieldThatDoesNotExist() { underTest = new ContentMatchesJsonPath("$.store.book[*].something", ""); assertThat("", underTest.test(failedMessage), is(false)); } @Test public void attemptToMatchAnyValueInArray() { underTest = new ContentMatchesJsonPath("$.store.book[*].category", "romance"); assertThat("No books should exist with category 'romance'", underTest.test(failedMessage), is(false)); } @Test public void successfullyMatchAntValueInArray() { underTest = new ContentMatchesJsonPath("$.store.book[*].category", "fiction"); assertThat(underTest.test(failedMessage), is(true)); } @Test public void messageContentIsNull() { when(failedMessage.getContent()).thenReturn(null); assertThat(underTest.test(failedMessage), is(false)); }
BrokerEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); } BrokerEqualsPredicate(@JsonProperty("broker") String broker); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
@Test public void nameOfBrokerMatchers() { when(destination.getBrokerName()).thenReturn("some-broker"); assertThat(underTest.test(failedMessage), is(true)); } @Test public void nameOfBrokerDoesNotMatch() { when(destination.getBrokerName()).thenReturn("another-broker"); assertThat(underTest.test(failedMessage), is(false)); }
MongoStatusHistoryQueryBuilder { public Document currentStatusNotEqualTo(Status status) { return new Document(STATUS_HISTORY + ".0." + STATUS, new Document(NE, status.name())); } Document currentStatusEqualTo(Status status); Document currentStatusNotEqualTo(Status status); Document currentStatusIn(Set<Status> statuses); Document currentStatusIn(Document query, Set<Status> statuses); }
@Test public void currentStatusNotEqualTo() { assertThat(underTest.currentStatusNotEqualTo(DELETED), hasField(STATUS_HISTORY + ".0." + STATUS, hasField(NE, equalTo(DELETED.name())))); }
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
@Test public void shortCutEvaluationWhenFirstPredicateIsTrue() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(true); assertThat(underTest.test(failedMessage), is(true)); verify(failedMessagePredicate1).test(failedMessage); verifyZeroInteractions(failedMessagePredicate2); } @Test public void bothPredicatesAreEvaluatedWhenFirstPredicateReturnsFalse() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(false); when(failedMessagePredicate2.test(failedMessage)).thenReturn(true); assertThat(underTest.test(failedMessage), is(true)); verify(failedMessagePredicate1).test(failedMessage); verify(failedMessagePredicate2).test(failedMessage); } @Test public void allPredicatesReturnFalse() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(false); when(failedMessagePredicate2.test(failedMessage)).thenReturn(false); assertThat(underTest.test(failedMessage), is(false)); verify(failedMessagePredicate1).test(failedMessage); verify(failedMessagePredicate2).test(failedMessage); }
OrPredicate implements FailedMessagePredicate { public List<FailedMessagePredicate> getPredicates() { return predicates; } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
@Test public void canSerialiseAndDeserialisePredicate() throws IOException { ObjectMapper objectMapper = JacksonConfiguration.defaultObjectMapper(); objectMapper.registerSubtypes(BooleanPredicate.class); final OrPredicate underTest = objectMapper.readValue( objectMapper.writeValueAsString(new OrPredicate(singletonList(alwaysTruePredicate))), OrPredicate.class ); assertThat(underTest.getPredicates(), contains(alwaysTruePredicate)); }
OrPredicate implements FailedMessagePredicate { @Override public <T> Description<T> describe(Description<T> description) { Description<T> finalDescription = description.append("( "); final Iterator<FailedMessagePredicate> iterator = predicates.iterator(); while (iterator.hasNext()) { finalDescription = iterator.next().describe(finalDescription); if (iterator.hasNext()) { finalDescription = finalDescription.append(" OR "); } } return finalDescription.append(" )"); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
@Test public void testDescribe() { when(failedMessagePredicate1.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate1")); when(failedMessagePredicate2.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate2")); assertThat(underTest.describe(new StringDescription()).getOutput(), is("( predicate1 OR predicate2 )")); }
OrPredicate implements FailedMessagePredicate { @Override public String toString() { return describe(new StringDescription()).toString(); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
@Test public void toStringTest() { when(failedMessagePredicate1.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate1")); when(failedMessagePredicate2.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate2")); assertThat(underTest.toString(), is("( predicate1 OR predicate2 )")); }
DeleteMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.delete(failedMessage.getFailedMessageId()); } DeleteMessageAction(@JacksonInject FailedMessageService failedMessageService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
@Test public void canSerialiseAndDeserialiseAction() throws Exception { DeleteMessageAction underTest = objectMapper.readValue( objectMapper.writeValueAsString(new DeleteMessageAction(failedMessageService)), DeleteMessageAction.class ); when(failedMessage.getFailedMessageId()).thenReturn(FAILED_MESSAGE_ID); underTest.accept(failedMessage); verify(failedMessageService).delete(FAILED_MESSAGE_ID); }
DeleteMessageAction implements FailedMessageAction { @Override public String toString() { return "delete failedMessage"; } DeleteMessageAction(@JacksonInject FailedMessageService failedMessageService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
@Test public void testToString() { assertThat(new DeleteMessageAction(failedMessageService).toString(), is("delete failedMessage")); }
LabelMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageLabelService.addLabel(failedMessage.getFailedMessageId(), label); } LabelMessageAction(@JsonProperty("label") String label, @JacksonInject FailedMessageLabelService failedMessageLabelService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
@Test public void canSerialiseAndDeserialiseAction() throws Exception { LabelMessageAction underTest = objectMapper.readValue( objectMapper.writeValueAsString(new LabelMessageAction("foo", failedMessageLabelService)), LabelMessageAction.class ); when(failedMessage.getFailedMessageId()).thenReturn(FAILED_MESSAGE_ID); underTest.accept(failedMessage); verify(failedMessageLabelService).addLabel(FAILED_MESSAGE_ID, "foo"); }
LabelMessageAction implements FailedMessageAction { @Override public String toString() { return "set label '" + label + "'"; } LabelMessageAction(@JsonProperty("label") String label, @JacksonInject FailedMessageLabelService failedMessageLabelService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
@Test public void testToString() { LabelMessageAction underTest = new LabelMessageAction("foo", failedMessageLabelService); assertThat(underTest.toString(), Matchers.is("set label 'foo'")); }
FailedMessageMongoDao implements FailedMessageDao { @Override public Optional<FailedMessage> findById(FailedMessageId failedMessageId) { return Optional.ofNullable(collection .find(failedMessageConverter.createId(failedMessageId)) .map(failedMessageConverter::convertToObject) .first()); } FailedMessageMongoDao(MongoCollection<Document> collection, FailedMessageConverter failedMessageConverter, DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter, RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
@Test public void findFailedMessageThatDoesNotExistReturnsNull() { assertThat(underTest.findById(newFailedMessageId()), is(Optional.empty())); }
ResendFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay, @JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay, FailedMessageService failedMessageService, Clock clock); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
@Test public void resendFailedMessageActionWithNullDelay() { ResendFailedMessageAction underTest = resendFailedMessageActionWithFixedClock(null); underTest.accept(failedMessage); verify(failedMessageService).update(eq(FAILED_MESSAGE_ID), statusUpdateRequest.capture()); assertThat(statusUpdateRequest.getValue(), aStatusUpdateRequest(RESEND).withUpdatedDateTime(FIXED_CLOCK.instant())); } @Test public void resendFailedMessageActionWithGivenDelay() { ResendFailedMessageAction underTest = resendFailedMessageActionWithFixedClock(Duration.ofSeconds(10)); underTest.accept(failedMessage); verify(failedMessageService).update(eq(FAILED_MESSAGE_ID), statusUpdateRequest.capture()); assertThat(statusUpdateRequest.getValue(), aStatusUpdateRequest(RESEND).withUpdatedDateTime(FIXED_CLOCK.instant().plusSeconds(10))); }
ResendFailedMessageAction implements FailedMessageAction { @Override public String toString() { return "resend in " + formatDurationHMS(getResendDelay().toMillis()); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay, @JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay, FailedMessageService failedMessageService, Clock clock); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
@Test public void testToString() { ResendFailedMessageAction underTest = resendFailedMessageActionWithFixedClock(Duration.ofDays(2).plusMinutes(15).plusSeconds(10).plusMillis(5)); assertThat(underTest.toString(), Matchers.is("resend in 48:15:10.005")); }
ChainedFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { actions.forEach(action -> action.accept(failedMessage)); } ChainedFailedMessageAction(@JsonProperty("actions") List<FailedMessageAction> actions); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
@Test public void allActionsInTheListAreExecuted() { ChainedFailedMessageAction underTest = new ChainedFailedMessageAction(Arrays.asList( failedMessageAction1, failedMessageAction2 )); underTest.accept(failedMessage); verify(failedMessageAction1).accept(failedMessage); verify(failedMessageAction2).accept(failedMessage); }
ChainedFailedMessageAction implements FailedMessageAction { @Override public String toString() { return actions.stream().map(Object::toString).collect(Collectors.joining(" AND ")); } ChainedFailedMessageAction(@JsonProperty("actions") List<FailedMessageAction> actions); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
@Test public void testToString() { when(failedMessageAction1.toString()).thenReturn("action1"); when(failedMessageAction2.toString()).thenReturn("action2"); ChainedFailedMessageAction underTest = new ChainedFailedMessageAction(Arrays.asList( failedMessageAction1, failedMessageAction2 )); assertThat(underTest.toString(), Matchers.is("action1 AND action2")); }
MessageClassificationOutcomeAdapter { public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); } MessageClassificationOutcomeAdapter(ObjectMapper objectMapper, FailedMessageResponseFactory failedMessageResponseFactory); MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome); }
@Test public void convertOutcomeToOutcomeResponse() throws JsonProcessingException { when(outcome.isMatched()).thenReturn(true); when(outcome.getFailedMessage()).thenReturn(failedMessage); when(outcome.getDescription()).thenReturn("Description"); when(outcome.getFailedMessageAction()).thenReturn(failedMessageAction); when(objectMapper.writeValueAsString(failedMessageAction)).thenReturn("Action"); when(failedMessageResponseFactory.create(failedMessage)).thenReturn(failedMessageResponse); final MessageClassificationOutcomeResponse response = underTest.toOutcomeResponse(outcome); assertThat(response.isMatched(), is(true)); assertThat(response.getFailedMessageResponse(), is(failedMessageResponse)); assertThat(response.getAction(), is("Action")); assertThat(response.getDescription(), is("Description")); } @Test public void actionIsClassNameWhenJsonProcessingExceptionIsThrown() throws JsonProcessingException { failedMessageAction = new StubFailedMessageAction(); when(outcome.isMatched()).thenReturn(true); when(outcome.getFailedMessage()).thenReturn(failedMessage); when(outcome.getDescription()).thenReturn("Description"); when(outcome.getFailedMessageAction()).thenReturn(failedMessageAction); when(objectMapper.writeValueAsString(failedMessageAction)).thenThrow(JsonProcessingException.class); when(failedMessageResponseFactory.create(failedMessage)).thenReturn(failedMessageResponse); final MessageClassificationOutcomeResponse response = underTest.toOutcomeResponse(outcome); assertThat(response.isMatched(), is(true)); assertThat(response.getFailedMessageResponse(), is(failedMessageResponse)); assertThat(response.getAction(), is("StubFailedMessageAction")); assertThat(response.getDescription(), is("Description")); }
MessageClassifierGroup implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
@Test public void noClassifiersMatch() { when(messageClassifier1.classify(context)).thenReturn(classifier1Outcome); when(messageClassifier2.classify(context)).thenReturn(classifier2Outcome); when(classifier1Outcome.isMatched()).thenReturn(false); when(finalOutcome.isMatched()).thenReturn(false); when(classifier1Outcome.or(classifier2Outcome)).thenReturn(finalOutcome); assertThat(underTest.classify(context), is(finalOutcome)); verify(messageClassifier1).classify(context); verify(messageClassifier2).classify(context); verify(classifier1Outcome).or(classifier2Outcome); } @Test public void firstClassifierMatches() { when(messageClassifier1.classify(context)).thenReturn(classifier1Outcome); when(classifier1Outcome.isMatched()).thenReturn(true); assertThat(underTest.classify(context), is(this.classifier1Outcome)); verify(messageClassifier1).classify(context); verifyZeroInteractions(messageClassifier2); }
MessageClassifierGroup implements MessageClassifier { public static Builder newClassifierCollection() { return new Builder(); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
@Test public void canSerialiseAndDeserialiseMessageClassifier() throws IOException { final ObjectMapper objectMapper = JacksonConfiguration.defaultObjectMapper(); objectMapper.registerSubtypes(DoNothingMessageClassifier.class); underTest = newClassifierCollection() .withClassifier(new DoNothingMessageClassifier()) .withClassifier(new DoNothingMessageClassifier()) .build(); final String json = objectMapper.writeValueAsString(underTest); assertThat(json, allOf( hasJsonPath("$._classifier", equalTo("collection")), hasJsonPath("$.classifiers[0]._classifier", equalTo("doNothing")), hasJsonPath("$.classifiers[1]._classifier", equalTo("doNothing")) )); assertThat(objectMapper.readValue(json, MessageClassifier.class), reflectionEquals(underTest)); }
FailedMessageMongoDao implements FailedMessageDao { @Override public long findNumberOfMessagesForBroker(String broker) { return collection.count(new Document(DESTINATION + "." + BROKER_NAME, broker)); } FailedMessageMongoDao(MongoCollection<Document> collection, FailedMessageConverter failedMessageConverter, DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter, RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
@Test public void findNumberOfMessagesForBroker() { underTest.insert(failedMessageBuilder .withNewFailedMessageId() .withDestination(new Destination("brokerA", of("queue-name"))) .build()); underTest.insert(failedMessageBuilder .withNewFailedMessageId() .withDestination(new Destination("brokerB", of("queue-name"))) .build()); assertThat(underTest.findNumberOfMessagesForBroker("brokerA"), is(1L)); }
MessageClassifierGroup implements MessageClassifier { @Override public String toString() { return messageClassifiers.stream().map(MessageClassifier::toString).collect(Collectors.joining(" OR ")); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
@Test public void testToString() { when(messageClassifier1.toString()).thenReturn("classifier1"); when(messageClassifier2.toString()).thenReturn("classifier2"); final MessageClassifierGroup underTest = newClassifierCollection().withClassifier(messageClassifier1).withClassifier(messageClassifier2).build(); assertThat(underTest.toString(), is("classifier1 OR classifier2")); }
ExecutingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate, @JsonProperty("action") FailedMessageAction action); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
@Test public void actionIsExecutedIfThePredicateIsTrue() { when(context.getFailedMessage()).thenReturn(failedMessage); when(predicate.test(failedMessage)).thenReturn(true); when(context.matched(predicate, action)).thenReturn(outcome); assertThat(underTest.classify(context), is(outcome)); verify(predicate).test(failedMessage); verify(context).matched(predicate, action); } @Test public void actionIsNotExecutedIfThePredicateIsFalse() { when(context.getFailedMessage()).thenReturn(failedMessage); when(predicate.test(failedMessage)).thenReturn(false); when(context.notMatched(predicate)).thenReturn(outcome); assertThat(underTest.classify(context), is(outcome)); verify(predicate).test(failedMessage); verify(context).notMatched(predicate); }
ExecutingMessageClassifier implements MessageClassifier { @Override public String toString() { return "if " + predicate + " then " + action; } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate, @JsonProperty("action") FailedMessageAction action); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
@Test public void testToString() { when(predicate.toString()).thenReturn("predicate"); when(action.toString()).thenReturn("action"); assertThat(underTest.toString(), is("if predicate then action")); }
MessageClassificationOutcome { public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); } MessageClassificationOutcome(boolean matched, FailedMessagePredicate predicate, FailedMessage failedMessage, FailedMessageAction action); boolean isMatched(); String getDescription(); Description<T> getDescription(Description<T> description); FailedMessage getFailedMessage(); void execute(); @Override String toString(); MessageClassificationOutcome and(MessageClassificationOutcome outcome); MessageClassificationOutcome or(MessageClassificationOutcome outcome); }
@Test public void getDefaultDescription() { when(matchedPredicate.describe(any(StringDescription.class))).thenAnswer((Answer<Description<String>>) invocation -> ((StringDescription)invocation.getArgument(0)).append("predicate1")); assertThat(matched().getDescription(), is(equalTo("matched = true, predicate1"))); } @Test public void getDescription() { assertThat(matched().getDescription(description), is(notNullValue(Description.class))); }
DelegatingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate, @JsonProperty("messageClassifier") MessageClassifier messageClassifier); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
@Test public void predicateIsNotMatched() { when(context.getFailedMessage()).thenReturn(failedMessage); when(predicate.test(failedMessage)).thenReturn(false); when(context.notMatched(predicate)).thenReturn(outcome); assertThat(underTest.classify(context), is(outcome)); verify(predicate).test(failedMessage); verify(context).notMatched(predicate); verifyZeroInteractions(messageClassifierGroup); } @Test public void predicateIsMatched() { when(context.getFailedMessage()).thenReturn(failedMessage); when(predicate.test(failedMessage)).thenReturn(true); MessageClassificationOutcome initialClassificationOutcome = mock(MessageClassificationOutcome.class); when(context.matched(predicate)).thenReturn(initialClassificationOutcome); MessageClassificationOutcome subsequentClassificationOutcome = mock(MessageClassificationOutcome.class); when(messageClassifierGroup.classify(context)).thenReturn(subsequentClassificationOutcome); when(initialClassificationOutcome.and(subsequentClassificationOutcome)).thenReturn(outcome); assertThat(underTest.classify(context), is(outcome)); verify(predicate).test(failedMessage); verify(context).matched(predicate); verify(initialClassificationOutcome).and(subsequentClassificationOutcome); }
DelegatingMessageClassifier implements MessageClassifier { @Override public String toString() { return "if " + predicate + " then " + messageClassifier; } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate, @JsonProperty("messageClassifier") MessageClassifier messageClassifier); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
@Test public void testToString() { when(predicate.toString()).thenReturn("predicate"); when(messageClassifierGroup.toString()).thenReturn("more classifiers"); assertThat(underTest.toString(), is("if predicate then more classifiers")); }
FailedMessagePredicateWithResult implements FailedMessagePredicate { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; FailedMessagePredicateWithResult that = (FailedMessagePredicateWithResult) o; return result == that.result && Objects.equals(predicate, that.predicate); } FailedMessagePredicateWithResult(@JsonProperty("result") boolean result, @JsonProperty("predicate") FailedMessagePredicate predicate); @Override boolean test(FailedMessage failedMessage); @Override Description<T> describe(Description<T> description); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }
@Test public void testEquals() { assertThat(underTest.equals(null), is(false)); assertThat(underTest.equals(new BooleanPredicate(true)), is(false)); assertThat(underTest.equals(new FailedMessagePredicateWithResult(false, failedMessagePredicate)), is(false)); assertThat(underTest.equals(new FailedMessagePredicateWithResult(true, mock(FailedMessagePredicate.class))), is(false)); assertThat(underTest.equals(new FailedMessagePredicateWithResult(true, failedMessagePredicate)), is(true)); }
FailedMessageMongoDao implements FailedMessageDao { @Override public long removeFailedMessages() { return collection.deleteMany(removeRecordsQueryFactory.create()).getDeletedCount(); } FailedMessageMongoDao(MongoCollection<Document> collection, FailedMessageConverter failedMessageConverter, DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter, RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
@Test public void removeOnAnEmptyCollection() { assertThat(underTest.removeFailedMessages(), is(0L)); }
FailedMessagePredicateWithResult implements FailedMessagePredicate { @Override public int hashCode() { return Objects.hash(result, predicate); } FailedMessagePredicateWithResult(@JsonProperty("result") boolean result, @JsonProperty("predicate") FailedMessagePredicate predicate); @Override boolean test(FailedMessage failedMessage); @Override Description<T> describe(Description<T> description); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }
@Test public void testHashCode() { assertThat(underTest.hashCode(), is(Arrays.hashCode(new Object[] {true, failedMessagePredicate}))); }
MessageClassificationContext { public MessageClassificationOutcome notMatched(FailedMessagePredicate predicate) { return new MessageClassificationOutcome(false, new FailedMessagePredicateWithResult(false, predicate), failedMessage,null); } MessageClassificationContext(FailedMessage failedMessage); FailedMessage getFailedMessage(); MessageClassificationOutcome matched(FailedMessagePredicate predicate); MessageClassificationOutcome matched(FailedMessagePredicate predicate, FailedMessageAction action); MessageClassificationOutcome notMatched(FailedMessagePredicate predicate); @Override boolean equals(Object o); @Override int hashCode(); final FailedMessage failedMessage; }
@Test public void notMatched() { final MessageClassificationOutcome outcome = underTest.notMatched(failedMessagePredicate); assertThat(outcome.isMatched(), is(false)); assertThat(outcome.getFailedMessage(), is(failedMessage)); assertThat(outcome.getFailedMessageAction(), is(nullValue())); assertThat(outcome.getFailedMessagePredicate(), is(new FailedMessagePredicateWithResult(false, failedMessagePredicate))); }
UnmatchedMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { return context.notMatched(new BooleanPredicate(false)); } private UnmatchedMessageClassifier(); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static final UnmatchedMessageClassifier ALWAYS_UNMATCHED; }
@Test public void testClassify() { when(context.getFailedMessage()).thenReturn(failedMessage); when(context.notMatched(new BooleanPredicate(false))).thenReturn(outcome); assertThat(underTest.classify(context), is(outcome)); }