String tagId = entry.getKey(); String tagDescription = entry.getValue(); String tagValue = additionalDetails.get(tagId); plan.addFeature(new Feature(tagId, tagDescription, tagValue));
private static final Feature NEW_FEATURE = new Feature() { @Override public boolean configure(FeatureContext context) { context.register(new ClientRequestFilter() { @Override public void filter(ClientRequestContext requestContext) throws IOException { //do your stuff here } }); return true; } };
Plan plan = new Plan(planId); Map<String, String> planDetails = planMap.get(planId); Iterator<Entry<String, String>> features = planDetails.entrySet().iterator(); Map<String, String> additionalDetails = planAdditionalDetailsMap.get(planId); while (features.hasNext()) { Entry<String, String> entry = features.next(); <pre><code>String tagId = entry.getKey(); String tagDescription = entry.getValue(); String tagValue = additionalDetails.get(tagId); plan.addFeature(new Feature(tagId, tagDescription, tagValue)); </code></pre> } return plan;
/** * Create new Feature. * * @param featureID * unique feature identifier. */ public FF4j createFeature(String featureName, boolean enable, String description) { return createFeature(new Feature(featureName, enable, description)); }
for (String item : items) { Feature feature = new Feature(); feature.setName(item); session.save(feature); }
Feature feat = new Feature(); feat.setFeat("T12"); myOb.setFeature(feat);
/** {@inheritDoc} */ @Override public Feature mapRow(ResultSet rs, int rowNum) throws SQLException { String featUid = rs.getString(COL_FEAT_UID); Feature f = new Feature(featUid, rs.getInt(COL_FEAT_ENABLE) > 0); f.setDescription(rs.getString(COL_FEAT_DESCRIPTION)); f.setGroup(rs.getString(COL_FEAT_GROUPNAME)); // Build Flipping Strategy From DataBase String strategy = rs.getString(COL_FEAT_STRATEGY); if (strategy != null && !"".equals(strategy)) { Map < String, String > initParams = MappingUtil.toMap(rs.getString(COL_FEAT_EXPRESSION)); FlippingStrategy flipStrategy = MappingUtil.instanceFlippingStrategy(featUid, strategy, initParams); f.setFlippingStrategy(flipStrategy); } return f; }
/** * TDD. */ @Test(expected = FeatureNotFoundException.class) public void testFeatureDoesNotExit() { // Given assertFf4j.assertThatFeatureDoesNotExist(F_DOESNOTEXIST); // When testedStore.update(new Feature(F_DOESNOTEXIST)); // Then, expect error }
@SuppressWarnings("unchecked") private static Feature parseFeatureMap(Map<String, Object> fMap) { Feature f = new Feature((String) fMap.get("uid")); f.setEnable((Boolean) fMap.get("enable")); f.setDescription((String) fMap.get("description")); f.setGroup((String) fMap.get("group")); // permissions List<String> perm = (ArrayList<String>) fMap.get("permissions"); f.setPermissions(new HashSet<String>()); if (perm != null) { f.getPermissions().addAll(perm); } // flipping strategy f.setFlippingStrategy(parseFlipStrategy(f.getUid(), (LinkedHashMap<String, Object>) fMap.get("flippingStrategy"))); // custom properties Map <String, Object > propertyMap = (Map < String, Object >) fMap.get("customProperties"); f.setCustomProperties(parseCustomProperties(propertyMap)); return f; }
/** * TDD. */ @Test public void testUpdateFlipMoreAutorisationNotExist() { // Given assertFf4j.assertThatFeatureHasNotRole(F1, ROLE_NEW); Set<String> rights2 = new HashSet<String>(Arrays.asList(new String[] { ROLE_USER, ROLE_NEW })); Feature fpBis = new Feature(F1, false, G1, "desci2", rights2); // When testedStore.update(fpBis); // Then assertFf4j.assertThatFeatureHasRole(F1, ROLE_USER); assertFf4j.assertThatFeatureHasRole(F1, ROLE_NEW); }
/** * TDD. */ @Test public void testPutAvoidDoublon() { // Given Assert.assertTrue(getCacheManager().listCachedFeatureNames().isEmpty()); // When getCacheManager().putFeature(new Feature("ff", false, DESCRIPTION)); getCacheManager().putFeature(new Feature("ff", false, DESCRIPTION)); getCacheManager().putFeature(new Feature("ff2", false, DESCRIPTION)); // Then Assert.assertEquals(2, getCacheManager().listCachedFeatureNames().size()); }
/** * TDD. */ @Test public void testPutSeveral() { // Given Assert.assertTrue(getCacheManager().listCachedFeatureNames().isEmpty()); // When getCacheManager().putFeature(new Feature("ff", false, DESCRIPTION)); getCacheManager().putFeature(new Feature("ff2", false, DESCRIPTION)); // Then Assert.assertEquals(2, getCacheManager().listCachedFeatureNames().size()); }
/** * TDD. */ @Test public void testClear() { // Given getCacheManager().putFeature(new Feature("ff", false, DESCRIPTION)); getCacheManager().putFeature(new Feature("ff2", false, DESCRIPTION)); getCacheManager().putFeature(new Feature("ff3", false, DESCRIPTION)); Assert.assertEquals(3, getCacheManager().listCachedFeatureNames().size()); // When getCacheManager().clearFeatures(); // Then Assert.assertTrue(getCacheManager().listCachedFeatureNames().isEmpty()); }
/** * Enable Feature. * * @param featureID * unique feature identifier. */ public FF4j enable(String featureID) { try { getFeatureStore().enable(featureID); } catch (FeatureNotFoundException fnfe) { if (this.autocreate) { getFeatureStore().create(new Feature(featureID, true)); } else { throw fnfe; } } return this; }
/** * Disable Feature. * * @param featureID * unique feature identifier. */ public FF4j disable(String featureID) { try { getFeatureStore().disable(featureID); } catch (FeatureNotFoundException fnfe) { if (this.autocreate) { getFeatureStore().create(new Feature(featureID, false)); } else { throw fnfe; } } return this; }
/** * TDD. */ @Test public void testUpdateFlipLessAutorisation() { // Given assertFf4j.assertThatFeatureExist(F2); assertFf4j.assertThatFeatureHasRole(F2, ROLE_USER); // When testedStore.update(new Feature(F2, false, null)); // Then assertFf4j.assertThatFeatureHasNotRole(F2, ROLE_USER); }
/** * TDD. */ @Test public void testPutOK() { // Given Feature ff = new Feature("ff", false, DESCRIPTION); Assert.assertFalse(getCacheManager().listCachedFeatureNames().contains(ff.getUid())); // When getCacheManager().putFeature(ff); // Then Assert.assertTrue(getCacheManager().listCachedFeatureNames().contains(ff.getUid())); }
/** * TDD. */ @Test public void testEvictOK() { // Given getCacheManager().putFeature(new Feature("ff", false, DESCRIPTION)); Assert.assertTrue(getCacheManager().listCachedFeatureNames().contains("ff")); // When getCacheManager().evictFeature("ff"); // Then Assert.assertFalse(getCacheManager().listCachedFeatureNames().contains("ff")); }
/** {@inheritDoc} */ @Override public Feature fromStore(Document document) { String featUid = document.getString(FEATURE_UUID); boolean status = document.getBoolean(FEATURE_ENABLE); Feature f = new Feature(featUid, status); f.setDescription(document.getString(FEATURE_DESCRIPTION)); f.setGroup(document.getString(FEATURE_GROUPNAME)); f.setPermissions(mapAuthorization(document)); f.setFlippingStrategy(mapStrategy(featUid, document)); f.setCustomProperties(mapCustomProperties(document)); return f; }
public FeatureActions createOrUpdateFeature(String featureUID, FeatureApiBean featureApiBean) { featureValidator.assertFeatureUIDIsNotBlank(featureApiBean.getUid()); featureValidator.assertFeatureIdsMatch(featureUID, featureApiBean.getUid()); Feature feature = new Feature(featureUID); feature.setDescription(featureApiBean.getDescription()); feature.setEnable(featureApiBean.isEnable()); feature.setGroup(featureApiBean.getGroup()); feature.setPermissions(new HashSet<String>(featureApiBean.getPermissions())); initFlippingStrategy(featureApiBean, feature); initProperties(featureApiBean, feature); if (ff4j.getFeatureStore().exist(featureUID)) { ff4j.getFeatureStore().update(feature); return FeatureActions.UPDATED; } else { ff4j.getFeatureStore().create(feature); return FeatureActions.CREATED; } }