{"id":78808,"date":"2020-09-20T16:33:18","date_gmt":"2020-09-20T16:33:18","guid":{"rendered":"https:\/\/www.baeldung.com\/?p=87393"},"modified":"2020-09-20T16:33:18","modified_gmt":"2020-09-20T16:33:18","slug":"guide-to-the-system-rules-library","status":"publish","type":"post","link":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/2020\/09\/20\/guide-to-the-system-rules-library\/","title":{"rendered":"Guide to the System Rules Library"},"content":{"rendered":"

<\/p>\n

1. Overview<\/h2>\n
<\/div>\n

Sometimes when writing unit tests, we may need to test code that interacts directly with the System<\/em><\/a> class. Typically in applications such as command-line tools which call System.exit<\/a><\/em> directly or read arguments using System.in<\/em>.<\/p>\n

In this tutorial, we’ll take a look at the most common features of a neat external library called System Rules<\/a> which provides a set of JUnit rules<\/a> for testing code that uses the System<\/em> class<\/strong>.<\/p>\n

2. Maven Dependencies<\/h2>\n
<\/div>\n

First, let\u2019s add the System Rules dependency<\/a> to our pom.xml<\/em>:<\/p>\n

<dependency>\r\n    <groupId>com.github.stefanbirkner<\/groupId>\r\n    <artifactId>system-rules<\/artifactId>\r\n    <version>1.19.0<\/version>\r\n<\/dependency><\/code><\/pre>\n
We’ll also add System Lambda<\/a> dependency which is available from Maven Central<\/a> as well:<\/p>\n
<dependency>\r\n    <groupId>com.github.stefanbirkner<\/groupId>\r\n    <artifactId>system-lambda<\/artifactId>\r\n    <version>1.1.0<\/version>\r\n<\/dependency><\/code><\/pre>\n
The reason for adding this last dependency is so we can also show examples where appropriate using <\/strong>JUnit5<\/strong><\/a>. As we know, in this version of JUnit, the rules model was replaced by extensions<\/a>.<\/p>\n
3. Working With System Properties<\/h2>\n
<\/div>\n
To quickly recap, the Java platform uses a Properties<\/em> object<\/a> to provide information about the local system and configuration. We can easily print out the properties:<\/p>\n
System.getProperties()\r\n  .forEach((key, value) -> System.out.println(key + \": \" + value));<\/code><\/pre>\n
As we can see, properties include information such as the current user, the current version of the Java runtime, and file path-name separator:<\/p>\n
java.version: 1.8.0_221\r\nfile.separator: \/\r\nuser.home: \/Users\/baeldung\r\nos.name: Mac OS X\r\n...<\/code><\/pre>\n
We can also set our own system properties by using the System.setProperty<\/em> method. Care should be taken when working with system properties from our tests, as these properties are JVM-global.<\/p>\n
For example, if we set a system property, we should ensure we restore the property to its original value when our test finishes or if a failure occurs. This can sometimes lead to cumbersome setup and tear down code. However, if we neglect to do this, it could lead to unexpected side-effects in our tests.<\/strong><\/p>\n
In the next section, we’ll see how we can provide, clean, and make sure we restore system property values after our tests complete in a concise and simple manner.<\/p>\n
4. Providing System Properties<\/h2>\n
<\/div>\n
Let’s imagine that we have a system property log_dir <\/em>which contains the location of where our logs should be written and our application sets this location when it starts up:<\/p>\n
System.setProperty(\"log_dir\", \"\/tmp\/baeldung\/logs\");<\/code><\/pre>\n
4.1. Provide a Single Property<\/h3>\n
<\/div>\n
Now let’s consider that from our unit test, we want to provide a different value. We can do this using the ProvideSystemProperty<\/em> rule:<\/p>\n
public class ProvidesSystemPropertyWithRuleUnitTest {\r\n    @Rule\r\n    public final ProvideSystemProperty providesSystemPropertyRule = new ProvideSystemProperty(\"log_dir\", \"test\/resources\");\r\n    @Test\r\n    public void givenProvideSystemProperty_whenGetLogDir_thenLogDirIsProvidedSuccessfully() {\r\n        assertEquals(\"log_dir should be provided\", \"test\/resources\", System.getProperty(\"log_dir\"));\r\n    }\r\n    \/\/ unit test definition continues\r\n}\r\n<\/code><\/pre>\n
Using the ProvideSystemProperty<\/em> rule, we can set an arbitrary value for a given system property for use from our tests.<\/strong> In this example, we set the log_dir<\/em> property to our test\/resources<\/em> directory, and from our unit test, simply assert that the test property value has been provided successfully.<\/p>\n
If we then print out the value of the log_dir<\/em> property when our test class completes:<\/p>\n
@AfterClass\r\npublic static void tearDownAfterClass() throws Exception {\r\n    System.out.println(System.getProperty(\"log_dir\"));\r\n}\r\n<\/code><\/pre>\n
We can see the value of the property has been restored to its original value:<\/p>\n
\/tmp\/baeldung\/logs<\/code><\/pre>\n
4.2. Providing Multiple Properties<\/h3>\n
<\/div>\n
If we need to provide multiple properties, we can use the and<\/em> method to chain as many property values together as we require for our test:<\/p>\n
@Rule\r\npublic final ProvideSystemProperty providesSystemPropertyRule = \r\n    new ProvideSystemProperty(\"log_dir\", \"test\/resources\").and(\"another_property\", \"another_value\")<\/code><\/pre>\n
4.3. Providing Properties From a File<\/h3>\n
<\/div>\n
Likewise, we also have the possibility of providing properties from a file or classpath resource using the ProvideSystemProperty<\/em> rule:<\/p>\n
@Rule\r\npublic final ProvideSystemProperty providesSystemPropertyFromFileRule = \r\n  ProvideSystemProperty.fromResource(\"\/test.properties\");\r\n@Test\r\npublic void givenProvideSystemPropertyFromFile_whenGetName_thenNameIsProvidedSuccessfully() {\r\n    assertEquals(\"name should be provided\", \"baeldung\", System.getProperty(\"name\"));\r\n    assertEquals(\"version should be provided\", \"1.0\", System.getProperty(\"version\"));\r\n}<\/code><\/pre>\n
In the above example, we assume that we have a test.properties<\/em> file on the classpath:<\/p>\n
name=baeldung\r\nversion=1.0<\/code><\/pre>\n
4.4. Providing Properties With JUnit5 and Lambdas<\/h3>\n
<\/div>\n
As we previously mentioned, we could also use the System Lamda version of the library to implement tests compatible with JUnit5.<\/p>\n
Let’s see how to implement our test using this version of the library:<\/p>\n
@BeforeAll\r\nstatic void setUpBeforeClass() throws Exception {\r\n    System.setProperty(\"log_dir\", \"\/tmp\/baeldung\/logs\");\r\n}\r\n@Test\r\nvoid givenSetSystemProperty_whenGetLogDir_thenLogDirIsProvidedSuccessfully() throws Exception {\r\n    restoreSystemProperties(() -> {\r\n        System.setProperty(\"log_dir\", \"test\/resources\");\r\n        assertEquals(\"log_dir should be provided\", \"test\/resources\", System.getProperty(\"log_dir\"));\r\n    });\r\n    assertEquals(\"log_dir should be provided\", \"\/tmp\/baeldung\/logs\", System.getProperty(\"log_dir\"));\r\n}<\/code><\/pre>\n
In this version, we can use the restoreSystemProperties<\/em> method to execute a given statement. Inside this statement, we can set up and provide the values we require for our system properties<\/strong>. As we can see after this method finishes execution, the value of log_dir<\/em> is the same as before \/tmp\/baeldung\/logs<\/em>.<\/p>\n
Unfortunately, there is no built-in support for providing properties from files using the restoreSystemProperties <\/em>method.<\/p>\n
5. Clearing System Properties<\/h2>\n
<\/div>\n
Sometimes we might want to clear a set of system properties when our test starts and restore their original values when the test finishes irrespective of whether it passes or fails.<\/p>\n
We can use the ClearSystemProperties<\/em> rule for this purpose:<\/p>\n
@Rule\r\npublic final ClearSystemProperties userNameIsClearedRule = new ClearSystemProperties(\"user.name\");\r\n@Test\r\npublic void givenClearUsernameProperty_whenGetUserName_thenNull() {\r\n    assertNull(System.getProperty(\"user.name\"));\r\n}<\/code><\/pre>\n
The system property user.name<\/em> is one of the predefined system properties, which contains the user account name. As expected in the above unit test, we clear this property and check it is empty from our test.<\/p>\n
Conveniently, we can also pass multiple property names to the ClearSystemProperties<\/em> constructor.<\/strong><\/p>\n
6. Mocking System.in<\/em><\/h2>\n
<\/div>\n
From time to time, we might create interactive command-line applications that read from System.in<\/em>.<\/p>\n
For this section, we’ll use a very simple example which reads a first name and surname from the standard input and concatenates them together:<\/p>\n
private String getFullname() {\r\n    try (Scanner scanner = new Scanner(System.in)) {\r\n        String firstName = scanner.next();\r\n        String surname = scanner.next();\r\n        return String.join(\" \", firstName, surname);\r\n    }\r\n}<\/code><\/pre>\n
System Rules contains the TextFromStandardInputStream<\/em> rule which we can use to specify the lines that should be provided when calling System.in<\/em>:<\/p>\n
@Rule\r\npublic final TextFromStandardInputStream systemInMock = emptyStandardInputStream();\r\n@Test\r\npublic void givenTwoNames_whenSystemInMock_thenNamesJoinedTogether() {\r\n    systemInMock.provideLines(\"Jonathan\", \"Cook\");\r\n    assertEquals(\"Names should be concatenated\", \"Jonathan Cook\", getFullname());\r\n}<\/code><\/pre>\n
We accomplish this by using the providesLines<\/em> method, which takes a varargs<\/a> parameter to enable specifying more than one value.<\/strong><\/p>\n
In this example, we provide two values before calling the getFullname<\/em> method, where System.in<\/em> is referenced. Our two provided line values will be returned each time we call scanner.next()<\/em>.<\/p>\n
Let’s take a look at how we can achieve the same in a JUnit 5 version of the test using System Lambda:<\/p>\n
@Test\r\nvoid givenTwoNames_whenSystemInMock_thenNamesJoinedTogether() throws Exception {\r\n    withTextFromSystemIn(\"Jonathan\", \"Cook\").execute(() -> {\r\n        assertEquals(\"Names should be concatenated\", \"Jonathan Cook\", getFullname());\r\n    });\r\n}<\/code><\/pre>\n
In this variation, we use the similarly named withTextFromSystemIn\u00a0<\/em>method, which lets us specify the provided System.in<\/em> values.<\/strong><\/p>\n
It is important to mention in both cases that after the test finishes, the original value of System.in<\/em> will be restored.<\/p>\n
7. Testing System.out<\/em> and System.err<\/em><\/h2>\n
<\/div>\n
In a previous tutorial, we saw how to use System Rules to unit test System.out.println()<\/a>.<\/em><\/p>\n
Conveniently, we can apply an almost identical approach for testing code which interacts with the standard error stream. This time we use the SystemErrRule<\/em>:<\/p>\n
@Rule\r\npublic final SystemErrRule systemErrRule = new SystemErrRule().enableLog();\r\n@Test\r\npublic void givenSystemErrRule_whenInvokePrintln_thenLogSuccess() {\r\n    printError(\"An Error occurred Baeldung Readers!!\");\r\n    Assert.assertEquals(\"An Error occurred Baeldung Readers!!\", \r\n      systemErrRule.getLog().trim());\r\n}\r\nprivate void printError(String output) {\r\n    System.err.println(output);\r\n}<\/code><\/pre>\n
Nice! Using the SystemErrRule<\/em>, we can intercept the writes to System.err<\/em>. First, we start logging everything written to System.err<\/em> by calling the enableLog<\/em> method on our rule. Then we simply call getLog<\/em> to get the text written to System.err since we called enableLog<\/em>.<\/p>\n
Now, let’s implement the JUnit5 version of our test:<\/p>\n
@Test\r\nvoid givenTapSystemErr_whenInvokePrintln_thenOutputIsReturnedSuccessfully() throws Exception {\r\n    String text = tapSystemErr(() -> {\r\n        printError(\"An error occurred Baeldung Readers!!\");\r\n    });\r\n    Assert.assertEquals(\"An error occurred Baeldung Readers!!\", text.trim());\r\n}<\/code><\/pre>\n
In this version, we make use of the tapSystemErr<\/em> method, which executes the statement and lets us capture the content passed to System.err<\/em>.<\/strong><\/p>\n
8. Handling System.exit<\/em><\/h2>\n
<\/div>\n
Command-line applications typically terminate by calling System.exit<\/em>. If we want to test such an application, it is likely that our test will terminate abnormally before it finishes when it encounters the code which calls System.exit<\/em>.<\/strong><\/p>\n
Thankfully, System Rules provides a neat solution to handle this using\u00a0the ExpectedSystemExit<\/em> rule:<\/p>\n
@Rule\r\npublic final ExpectedSystemExit exitRule = ExpectedSystemExit.none();\r\n@Test\r\npublic void givenSystemExitRule_whenAppCallsSystemExit_thenExitRuleWorkssAsExpected() {\r\n    exitRule.expectSystemExitWithStatus(1);\r\n    exit();\r\n}\r\nprivate void exit() {\r\n    System.exit(1);\r\n}<\/code><\/pre>\n
Using the ExpectedSystemExit<\/em> rule allows us to specify from our test the expected System.exit()<\/em> call. In this simple example, we also check the expected status code using the expectSystemExitWithStatus<\/em> method.<\/p>\n
We can achieve something similar in our JUnit 5 version using the catchSystemExit<\/em> method<\/strong>:<\/p>\n
@Test\r\nvoid givenCatchSystemExit_whenAppCallsSystemExit_thenStatusIsReturnedSuccessfully() throws Exception {\r\n    int statusCode = catchSystemExit(() -> {\r\n        exit();\r\n    });\r\n    assertEquals(\"status code should be 1:\", 1, statusCode);\r\n}<\/code><\/pre>\n
9. Conclusion<\/h2>\n
<\/div>\n
To summarize, in this tutorial, we’ve explored the System Rules library in detail.<\/p>\n
First, we started by explaining how to test code that uses system properties. Then we looked at how to test the standard output and standard input. Finally, we looked at how to handle code which calls System.exit<\/em> from our tests.<\/p>\n
The System Rules library also provides support for providing environment variables and special security mangers from our tests<\/strong>. Be sure to check out the full documentation<\/a> for details.<\/p>\n
As always, the full source code of the article is available\u00a0over on GitHub<\/a>.<\/p>\n
The post Guide to the System Rules Library<\/a> first appeared on Baeldung<\/a>.<\/p>\n
\"\"<\/p>\n
<\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/div>\n\n
\\\"IT\u96fb\u8166\u88dc\u7fd2
\u7acb\u523b\u8a3b\u518a\u53ca\u5831\u540d\u96fb\u8166\u88dc\u7fd2\u8ab2\u7a0b\u5427!<\/figcaption><\/figure>\r\n<\/br>Find A Teacher Form:\r\n<\/br>https:\/\/docs.google.com\/forms\/d\/1vREBnX5n262umf4wU5U2pyTwvk9O-JrAgblA-wH9GFQ\/viewform?edit_requested=true#responses\r\n<\/br><\/br>Email:\r\n<\/br>public1989two@gmail.com






\r\nwww.itsec.hk<\/a>
\r\nwww.itsec.vip<\/a>
\r\nwww.itseceu.uk<\/a>
<\/p>","protected":false},"excerpt":{"rendered":"
Explore the System Rules library in detail.<\/p>\n
The post Guide to the System Rules Library<\/a> first appeared on Baeldung<\/a>.<\/p>\n
<\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/div>\n<\/div>","protected":false},"author":881,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"slim_seo":{"title":"Guide to the System Rules Library - ITTeacherITFreelance.hk","description":"Explore the System Rules library in detail. The post Guide to the System Rules Library first appeared on Baeldung .             &n"},"footnotes":""},"categories":[6],"tags":[],"_links":{"self":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/78808"}],"collection":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/users\/881"}],"replies":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/comments?post=78808"}],"version-history":[{"count":9,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/78808\/revisions"}],"predecessor-version":[{"id":83112,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/78808\/revisions\/83112"}],"wp:attachment":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/media?parent=78808"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/categories?post=78808"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/tags?post=78808"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}