(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (def var1 (ref 10))
   (def var2 (ref 20))
   (println @var1 @var2)
   
   (defn change-value [var1 var2 newvalue]
      (dosync
         (alter var1 - newvalue)
         (alter var2 + newvalue)))
   (change-value var1 var2 20)
   (println @var1 @var2))
(Example)

In the above example, we have two values which are being changed in a dosync block. If the transaction is successful, both values will change else the whole transaction will fail.

The above program produces the following output.

Output

10 20
-10 40

Clojure – Applications

Clojure has some contributed libraries which have the enablement for creating Desktop and Web-based applications. Let’s discuss each one of them.

Web Applications – Introduction

To create a web application in Clojure you need to use the Ring application library, which is available at the following link https://github.com/ring-clojure/ring

You need to ensure you download the necessary jars from the site and ensure to add it as a dependency for the Clojure application.

The Ring framework provides the following capabilities −

• Sets things up such that an http request comes into your web application as a regular Clojure HashMap, and likewise makes it so that you can return a response as a HashMap.

• Provides a specification describing exactly what those request and response maps should look like.

• Brings along a web server (Jetty) and connects your web application to it.

The Ring framework automatically can start a web server and ensures the Clojure application works on this server. Then one can also use the Compojure framework. This allows one to create routes which is now how most modern web applications are developed.

Creating your first Clojure application − The following example shows how you can create your first web application in Clojure.

(ns my-webapp.handler
   (:require [compojure.core :refer :all]
      [compojure.route :as route]
      [ring.middleware.defaults :refer [wrap-defaults site-defaults]]))
(defroutes app-routes
   (GET "/" [] "Hello World")
   (route/not-found "Not Found"))
(def app
   (wrap-defaults app-routes site-defaults))

Let’s look at the following aspects of the program −

• The ‘defroutes’ is used to create routes so that request made to the web application to different routes can be directed to different functions in your Clojure application.

• In the above example, the “/” is known as the default route, so when you browse to the base of your web application, the string “Hello World” will be sent to the web browser.

• If the user hits any url which cannot be processed by the Clojure application, then it will display the string “Not Found”.

When you run the Clojure application, by default your application will be loaded as localhost:3000, so if you browse to this location, you will receive the following output.

Web Applications – Adding More Routes to Your Web Application

You can also add more routes to your web application. The following example shows how to achieve this.

(ns my-webapp.handler
   (:require [compojure.core :refer :all]
      [compojure.route :as route]
      [ring.middleware.defaults :refer [wrap-defaults site-defaults]]))
(defroutes app-routes
   (GET "/" [] "Hello World")
   (GET "/Tutorial" [] "This is a tutorial on Clojure")
   (route/not-found "Not Found"))
(def app
   (wrap-defaults app-routes site-defaults))

You can see that adding a route in the application is as easy as just adding another GET function with the url route. (GET “/Tutorial” [] “This is a tutorial on Clojure”)

If you browse to the location http://localhost:3000/Tutorial, you will receive the following output.

Clojure – Automated Testing

In this chapter, let’s discuss automated testing options provided by Clojure.

Testing for Client Applications

In order to use testing for Clojure framework, you have to use the dependencies located at https://github.com/slagyr/speclj#manual-installation

This URL provides the speclj framework, which is used as a Test data driven or Behaviour driven test framework for Clojure. You have to ensure that you use the Clojure 1.7.0 framework when using any of the ‘speclj’ libraries. By default, the test files will be different from the Clojure code files and need to be placed in a ‘spec’ directory.

Following is a sample code for a test file.

(ns change.core-spec
   (:require [speclj.core :refer :all]))
(describe "Truth"
   (it "is true"
   (should true))
   (it "is not false"
   (should-not false)))
(run-specs)

Following things need to be noted about the above code −

• We first have to ensure to use the ‘require’ statement to include all the core libraries in the ‘speclj’ framework.

• Next is the ‘describe’ function. This is used to provide a description for the test case being created.

• Next function is the ‘it’ function, which is the actual test case. In the first test case, the “is true” string is the name given to the test case.

• Should and should-not are known as assertions. All assertions begin with should. Should and should-not are just two of the many assertions available. They both take expressions that they will check for truthy-ness and falsy-ness respectively.

If you run the test case, you will get the following output. The output shows the time taken in milliseconds for the test case to run.

←[32m.←[0m←[32m.←[0m
Finished in 0.00014 seconds

Testing for Web-based Applications

Selenium is one of the key frameworks used for testing modern day web-based applications. Clojure libraries are also available which can be used for testing web-based applications.

Let’s look at how we can use the Selenium libraries for testing Clojure web-based applications.

Step 1 − The first step is to ensure we are using the Ring and Compojure framework to create a web-based application, which needs to be tested. Let’s use one of the examples from our earlier chapters. The following code is a simple web application, which displays “Hello World” in the browser.

(ns my-webapp.handler
   (:require [compojure.core :refer :all]
      [compojure.route :as route]
      [ring.middleware.defaults :refer [wrap-defaults site-defaults]]))
(defroutes app-routes
   (GET "/" [] "Hello World")
   (route/not-found "Not Found"))
(def app
   (wrap-defaults app-routes site-defaults))

Step 2 − Next make sure to download the selenium jar file https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-server/2.47.0 and include it in your classpath.

Step 3 − Also ensure to download the ‘clj’ web driver, which will be used for running the web test from the following location.

https://clojars.org/clj-webdriver/versions/0.7.1

Step 4 − In your project directory, create another directory called features and create a file called ‘config.clj’.

Step 5 − Next add the following code to the ‘config.clj’ file created in the earlier step.

ns clj-webdriver-tutorial.features.config)
(def test-port 3000)
(def test-host "localhost")
(def test-base-url (str "http://" test-host ":" test-port "/"))

The above code basically tells the web test framework to test the application, which gets loaded at the URL http://localhost:3000

Step 6 − Finally, let’s write our code to carry out our test.

(ns clj-webdriver-tutorial.features.homepage
   (:require [clojure.test :refer :all]
      [ring.adapter.jetty :refer [run-jetty]]
      [clj-webdriver.taxi :refer :all]
      [clj-webdriver-tutorial.features.config :refer :all]
      [clj-webdriver-tutorial.handler :refer [app-routes]]))
(ns clj-webdriver-tutorial.features.homepage
   (:require [clojure.test :refer :all]
      [ring.adapter.jetty :refer [run-jetty]]
      [clj-webdriver.taxi :refer :all]
      [clj-webdriver-tutorial.features.config :refer :all]
      [clj-webdriver-tutorial.handler :refer [app-routes]]))
(defn start-server []
   (loop [server (run-jetty app-routes {:port test-port, :join? false})]
      (if (.isStarted server)
         server
         (recur server))))
(defn stop-server [server]
   (.stop server))
(defn start-browser []
   (set-driver! {:browser :firefox}))
(defn stop-browser []
   (quit))
(deftest homepage-greeting
   (let [server (start-server)]
      (start-browser)
      (to test-base-url)
      (is (= (text "body") "Hello World"))
      (stop-browser)
      (stop-server server)))

The above code is going to take the following actions −

• Start the server for the application.
• Open the root path in the browser.
• Check if the “Hello World” message is present on the page.
• Close the browser.
• Shut down the server.

Clojure – Libraries

One thing which makes the Clojure library so powerful is the number of libraries available for the Clojure framework. We have already seen so many libraries used in our earlier examples for web testing, web development, developing swing-based applications, the jdbc library for connecting to MySQL databases. Following are just a couple of examples of few more libraries.

data.xml

This library allows Clojure to work with XML data. The library version to be used is org.clojure/data.xml “0.0.8”. The data.xml supports parsing and emitting XML. The parsing functions will read XML from a Reader or InputStream.

Example

Following is an example of the data processing from a string to XML.

(ns clojure.examples.example
   (use ''clojure.data.xml)
   (:gen-class))
(defn Example []
   (let [input-xml (java.io.StringReader. "<?xml version = "1.0"
      encoding = "UTF-8"?><example><clo><Tutorial>The Tutorial
      value</Tutorial></clo></example>")]
      (parse input-xml)))

#clojure.data.xml.Element{
   :tag :example, :attrs {}, :content (#clojure.data.xml.Element {
      :tag :clo, :attrs {}, :content (#clojure.data.xml.Element {
         :tag :Tutorial, :attrs {},:content ("The Tutorial value")})})}
(Example)

data.json

This library allows Clojure to work with JSON data. The library version to be used is org.clojure/data.json “0.2.6”.

Example

Following is an example on the use of this library.

(ns clojure.examples.example
   (:require [clojure.data.json :as json])
   (:gen-class))
(defn Example []
   (println (json/write-str {:a 1 :b 2})))
(Example)

{"a":1,"b":2}

(ns clojure.examples.example
   (require ''[clojure.data.csv :as csv]
      ''[clojure.java.io :as io])
   (:gen-class))
(defn Example []
   (with-open [in-file (io/reader "in-file.csv")]
      (doall
      (csv/read-csv in-file)))
   (with-open [out-file (io/writer "out-file.csv")]
   (csv/write-csv out-file
      [[":A" "a"]
      [":B" "b"]])))
(Example)