Exemple #1
0
 /** @see {@link LogicService#getRule(String)} */
 @Test
 @Verifies(value = "should return ReferenceRule", method = "getRule(String)")
 public void getRule_shouldReturnReferenceRule() throws Exception {
   Rule rule = Context.getLogicService().getRule("%%person.birthdate");
   Assert.assertNotNull(rule);
   Assert.assertTrue(rule.getClass().isAssignableFrom(ReferenceRule.class));
 }
Exemple #2
0
  /** TODO: should we still support this kind of notation? */
  public void shouldReferenceRule() {
    LogicService logicService = Context.getLogicService();
    Cohort patients = new Cohort();
    Map<Integer, Result> result = null;

    patients.addMember(2);

    try {

      result = logicService.eval(patients, "%%obs.CD4 COUNT");
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("%%obs.CD4 COUNT").first());
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("%%person.BIRTHDATE"));
      Assert.assertNotNull(result);

      Calendar cal = Calendar.getInstance();
      cal.set(Calendar.YEAR, 1980);
      cal.set(Calendar.MONTH, 0);
      cal.set(Calendar.DAY_OF_MONTH, 1);
      result =
          logicService.eval(
              patients, new LogicCriteriaImpl("%%person.BIRTHDATE").before(cal.getTime()));
      Assert.assertNotNull(result);
    } catch (LogicException e) {
      log.error("Error generated", e);
    }
  }
Exemple #3
0
 /** @see {@link LogicService#getRule(String)} */
 @Test(expected = LogicException.class)
 @Verifies(
     value = "should fail when no Rule is associated with the input token",
     method = "getRule(String)")
 public void getRule_shouldFailWhenNoRuleIsAssociatedWithTheInputToken() throws Exception {
   Rule rule = Context.getLogicService().getRule("UNKNOWN RULE");
   Assert.assertNull(rule);
 }
Exemple #4
0
 /** @see {@link LogicService#findToken(String)} */
 @Test
 @Verifies(
     value = "should return all registered token matching the input fully",
     method = "getTokens(String)")
 public void getTokens_shouldReturnAllRegisteredTokenMatchingTheInputFully() throws Exception {
   LogicService logicService = Context.getLogicService();
   List<String> tokens = logicService.getTokens("AGE");
   Assert.assertEquals(1, tokens.size());
 }
Exemple #5
0
 /** @see {@link LogicService#getRule(String)} */
 @Test
 @Verifies(
     value = "should return Rule associated with the input token",
     method = "getRule(String)")
 public void getRule_shouldReturnRuleAssociatedWithTheInputToken() throws Exception {
   Rule ageRule = Context.getLogicService().getRule("AGE");
   Assert.assertNotNull(ageRule);
   Assert.assertTrue(AgeRule.class.isAssignableFrom(ageRule.getClass()));
 }
Exemple #6
0
  /** @see {@link LogicService#removeRule(String)} */
  @Test(expected = LogicException.class)
  @Verifies(value = "should remove rule", method = "removeRule(String)")
  public void removeRule_shouldRemoveRule() throws Exception {
    LogicService logicService = Context.getLogicService();
    Rule ageRule = logicService.getRule("AGE");
    Assert.assertNotNull(ageRule);

    logicService.removeRule("AGE");
    Rule afterDeleteAgeRule = logicService.getRule("AGE");
    Assert.assertNull(afterDeleteAgeRule);
  }
Exemple #7
0
  /** @see {@link LogicService#addTokenTag(String,String)} */
  @Test
  @Verifies(value = "should add tag for a token", method = "addTokenTag(String,String)")
  public void addTokenTag_shouldAddTagForAToken() throws Exception {
    LogicService logicService = Context.getLogicService();

    int initialTags = logicService.getTokenTags("HIV POSITIVE").size();

    logicService.addTokenTag("HIV POSITIVE", "a tag");

    int finalTags = logicService.getTokenTags("HIV POSITIVE").size();

    Assert.assertEquals(initialTags + 1, finalTags);
  }
Exemple #8
0
  /** @see {@link LogicService#findToken(String)} */
  @Test
  @Verifies(
      value = "should return all registered token matching the input partially",
      method = "getTokens(String)")
  public void getTokens_shouldReturnAllRegisteredTokenMatchingTheInputPartially() throws Exception {
    LogicService logicService = Context.getLogicService();

    Context.getService(TokenService.class)
        .registerToken("One Another", new ClassRuleProvider(), "one");
    Context.getService(TokenService.class)
        .registerToken("Two Another", new ClassRuleProvider(), "two");

    List<String> tokens = logicService.getTokens("ANOTHER");
    Assert.assertEquals(2, tokens.size());
  }
Exemple #9
0
  /** @see {@link LogicService#getTokensByTag(String)} */
  @Test
  @Verifies(
      value = "should return set of token associated with a tag",
      method = "getTokensWithTag(String)")
  public void getTokensWithTag_shouldReturnSetOfTokenAssociatedWithATag() throws Exception {
    LogicService logicService = Context.getLogicService();

    String[] setOfTags = {"birth", "date", "born"};

    Context.getService(TokenService.class)
        .registerToken("ANOTHER AGE RULE", new ClassRuleProvider(), AgeRule.class.getName());
    for (String tag : setOfTags) logicService.addTokenTag("ANOTHER AGE RULE", tag);

    Collection<String> tokens = logicService.getTokensWithTag("birth");
    Assert.assertEquals(1, tokens.size());
  }
Exemple #10
0
  /** TODO make this test use assert statements instead of printing to stdout */
  @Test
  public void shouldHIVPositiveRule() {
    LogicService logicService = Context.getLogicService();
    Cohort patients = new Cohort();
    Map<Integer, Result> result = null;

    patients.addMember(2);

    try {

      result =
          logicService.eval(
              patients,
              new LogicCriteriaImpl("PROBLEM ADDED")
                  .contains("HUMAN IMMUNODEFICIENCY VIRUS")
                  .first());
      Assert.assertNotNull(result);

      result =
          logicService.eval(
              patients, new LogicCriteriaImpl("PROBLEM ADDED").contains("HIV INFECTED").first());
      Assert.assertNotNull(result);

      result =
          logicService.eval(
              patients,
              new LogicCriteriaImpl("PROBLEM ADDED")
                  .contains("ASYMPTOMATIC HIV INFECTION")
                  .first());
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("HIV VIRAL LOAD").first());
      Assert.assertNotNull(result);

      result =
          logicService.eval(patients, new LogicCriteriaImpl("HIV VIRAL LOAD, QUALITATIVE").first());
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT").lt(200).first());
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("HIV POSITIVE"));
      Assert.assertNotNull(result);
    } catch (LogicException e) {
      log.error("Error generated", e);
    }
  }
Exemple #11
0
  /** @see {@link LogicService#findTags(String)} */
  @Test
  @Verifies(
      value = "should return set of tags matching input tag partially",
      method = "getTags(String)")
  public void getTags_shouldReturnSetOfTagsMatchingInputTagPartially() throws Exception {
    LogicService logicService = Context.getLogicService();
    TokenService tokenService = Context.getService(TokenService.class);

    String[] similarTags = {"tags01", "tags02", "tags03", "tags04", "tags05"};
    Rule rule = logicService.getRule("AGE");
    Assert.assertNotNull(rule);

    tokenService.registerToken("ANOTHER AGE", new ClassRuleProvider(), AgeRule.class.getName());
    for (String tag : similarTags) logicService.addTokenTag("ANOTHER AGE", tag);

    List<String> tags = logicService.getTags("tags");

    Assert.assertEquals(similarTags.length, tags.size());
  }
Exemple #12
0
  /** @see {@link LogicService#removeTokenTag(String,String)} */
  @Test
  @Verifies(value = "should remove tag from a token", method = "removeTokenTag(String,String)")
  public void removeTokenTag_shouldRemoveTagFromAToken() throws Exception {
    LogicService logicService = Context.getLogicService();

    String[] setOfTags = {"birth", "date", "born"};

    Context.getService(TokenService.class)
        .registerToken("ANOTHER AGE RULE", new ClassRuleProvider(), AgeRule.class.getName());
    for (String tag : setOfTags) logicService.addTokenTag("ANOTHER AGE RULE", tag);

    Collection<String> retrievedTags = logicService.getTokenTags("ANOTHER AGE RULE");
    Assert.assertEquals(setOfTags.length, retrievedTags.size());

    logicService.removeTokenTag("ANOTHER AGE RULE", "date");

    retrievedTags = logicService.getTokenTags("ANOTHER AGE RULE");
    Assert.assertEquals(setOfTags.length - 1, retrievedTags.size());
  }
Exemple #13
0
  /** @see {@link LogicService#getTagsByToken(String)} */
  @Test
  @Verifies(
      value = "should return set of tags for a certain token",
      method = "getTokenTags(String)")
  public void getTokenTags_shouldReturnSetOfTagsForACertainToken() throws Exception {
    LogicService logicService = Context.getLogicService();

    String[] setOfTags = {"birth", "date", "born"};

    Context.getService(TokenService.class)
        .registerToken("ANOTHER AGE RULE", new ClassRuleProvider(), AgeRule.class.getName());
    for (String tag : setOfTags) logicService.addTokenTag("ANOTHER AGE RULE", tag);

    Set<String> retrievedTags = logicService.getTokenTags("ANOTHER AGE RULE");
    Assert.assertEquals(setOfTags.length, retrievedTags.size());

    logicService.addTokenTag("ANOTHER AGE RULE", "tag");

    retrievedTags = logicService.getTokenTags("ANOTHER AGE RULE");
    Assert.assertEquals(setOfTags.length + 1, retrievedTags.size());
  }
Exemple #14
0
  /** TODO make this test use assert statements instead of printing to stdout */
  @Test
  public void shouldDemographicsRule() {
    LogicService logicService = Context.getLogicService();
    Cohort patients = new Cohort();
    Map<Integer, Result> result;

    patients.addMember(2);

    try {
      result = logicService.eval(patients, new LogicCriteriaImpl("BIRTHDATE"));
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("AGE"));
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("AGE").gt(10));
      Assert.assertNotNull(result);

      Calendar cal = Calendar.getInstance();
      cal.set(Calendar.YEAR, 2000);
      result = logicService.eval(patients, new LogicCriteriaImpl("BIRTHDATE").after(cal.getTime()));
      Assert.assertNotNull(result);

      result =
          logicService.eval(patients, new LogicCriteriaImpl("BIRTHDATE").before(cal.getTime()));
      Assert.assertNotNull(result);

      // test the index date functionality
      Calendar index = Calendar.getInstance();
      index.set(1970, 0, 1);
      result = logicService.eval(patients, new LogicCriteriaImpl("BIRTHDATE"));
      Assert.assertNotNull(result);

      result =
          logicService.eval(patients, new LogicCriteriaImpl("BIRTHDATE").within(Duration.years(5)));
      Assert.assertNotNull(result);
    } catch (LogicException e) {
      log.error("testDemographicsRule: Error generated", e);
    }
  }
Exemple #15
0
 /** @see {@link LogicService#getTokens()} */
 @Test
 @Verifies(value = "should return all registered token", method = "getAllTokens()")
 public void getAllTokens_shouldReturnAllRegisteredToken() throws Exception {
   Collection<String> tokens = Context.getLogicService().getAllTokens();
   Assert.assertEquals(19, tokens.size());
 }
Exemple #16
0
 /** @see {@link LogicService#findToken(String)} */
 @Test
 @Verifies(value = "should not fail when input is null", method = "getTokens(String)")
 public void getTokens_shouldNotFailWhenInputIsNull() throws Exception {
   Collection<String> tokens = Context.getLogicService().getTokens(null);
   Assert.assertNotNull(tokens);
 }
Exemple #17
0
  /** TODO make this test use assert statements instead of printing to stdout */
  @Test
  public void shouldObservationRule() {
    LogicService logicService = Context.getLogicService();
    Cohort patients = new Cohort();
    Map<Integer, Result> result = null;

    patients.addMember(2);

    try {
      Result r = logicService.eval(2, new LogicCriteriaImpl("CD4 COUNT"));
      Assert.assertNotNull(r);
      Assert.assertEquals(0, r.size());

      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT"));
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT").lt(170));
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT").gt(185));
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT").equalTo(190));
      Assert.assertNotNull(result);

      Calendar cal = Calendar.getInstance();
      cal.set(2006, 3, 11);
      result =
          logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT").before(cal.getTime()));
      Assert.assertNotNull(result);

      result =
          logicService.eval(
              patients, new LogicCriteriaImpl("CD4 COUNT").lt(190).before(cal.getTime()));
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT").after(cal.getTime()));
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT").last());
      Assert.assertNotNull(result);

      result =
          logicService.eval(
              patients, new LogicCriteriaImpl("CD4 COUNT").last().before(cal.getTime()));
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT").not().lt(150));
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT").not().not().lt(150));
      Assert.assertNotNull(result);

      patients.addMember(2);
      patients.addMember(3);
      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT").lt(200));
      Assert.assertNotNull(result);

      patients.addMember(39);
      result =
          logicService.eval(
              patients,
              new LogicCriteriaImpl("PROBLEM ADDED").contains("HUMAN IMMUNODEFICIENCY VIRUS"));
      Assert.assertNotNull(result);

      result = logicService.eval(patients, new LogicCriteriaImpl("CD4 COUNT"));
      Assert.assertNotNull(result);

      result =
          logicService.eval(
              patients, new LogicCriteriaImpl("CD4 COUNT").within(Duration.months(1)));
      Assert.assertNotNull(result);

    } catch (LogicException e) {
      log.error("testObservationRule: Error generated", e);
    }
  }
public class getLastObs implements Rule {
  private Log log = LogFactory.getLog(this.getClass());
  private LogicService logicService = Context.getLogicService();

  /**
   * *
   *
   * @see org.openmrs.logic.rule.Rule#getParameterList()
   */
  public Set<RuleParameterInfo> getParameterList() {
    return null;
  }

  /**
   * *
   *
   * @see org.openmrs.logic.rule.Rule#getDependencies()
   */
  public String[] getDependencies() {
    return new String[] {};
  }

  /**
   * *
   *
   * @see org.openmrs.logic.rule.Rule#getTTL()
   */
  public int getTTL() {
    return 0; // 60 * 30; // 30 minutes
  }

  /**
   * *
   *
   * @see org.openmrs.logic.rule.Rule#getDatatype(String)
   */
  public Datatype getDefaultDatatype() {
    return Datatype.CODED;
  }

  /**
   * Limits results by a given encounter id
   *
   * @see org.openmrs.logic.Rule#eval(org.openmrs.logic.LogicContext, org.openmrs.Patient,
   *     java.util.Map)
   */
  public Result eval(LogicContext context, Integer patientId, Map<String, Object> parameters)
      throws LogicException {
    if (parameters == null) {
      return Result.emptyResult();
    }

    String conceptName = (String) parameters.get("param1");

    if (conceptName == null) {
      return Result.emptyResult();
    }
    Result ruleResult = null;

    Integer encounterId = (Integer) parameters.get("encounterId");

    if (encounterId == null) {
      return Result.emptyResult();
    }

    LogicCriteria conceptCriteria = new LogicCriteriaImpl(conceptName);

    LogicCriteria fullCriteria = null;

    LogicCriteria encounterCriteria =
        new LogicCriteriaImpl("encounterId").equalTo(encounterId.intValue());

    fullCriteria = conceptCriteria.and(encounterCriteria);

    ruleResult = context.read(patientId, context.getLogicDataSource("obs"), fullCriteria.last());

    if (ruleResult != null && ruleResult.size() > 0) {
      return ruleResult.get(0);
    }
    return Result.emptyResult();
  }
}