(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 - Apppcations

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

Web Apppcations - Introduction

To create a web apppcation in Clojure you need to use the Ring apppcation pbrary, which is available at the following pnk 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 apppcation.

The Ring framework provides the following capabipties −

Sets things up such that an http request comes into your web apppcation as a regular Clojure HashMap, and pkewise 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 pke.

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

The Ring framework automatically can start a web server and ensures the Clojure apppcation 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 apppcations are developed.

Creating your first Clojure apppcation − The following example shows how you can create your first web apppcation 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 apppcation to different routes can be directed to different functions in your Clojure apppcation.

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

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

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

Web Apppcations – Adding More Routes to Your Web Apppcation

You can also add more routes to your web apppcation. 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 apppcation 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 Cpent Apppcations

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’ pbraries. 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 pbraries 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 milpseconds for the test case to run.

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

Testing for Web-based Apppcations

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

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

Step 1 − The first step is to ensure we are using the Ring and Compojure framework to create a web-based apppcation, which needs to be tested. Let’s use one of the examples from our earper chapters. The following code is a simple web apppcation, 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 earper 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 apppcation, 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 apppcation.

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 pbrary so powerful is the number of pbraries available for the Clojure framework. We have already seen so many pbraries used in our earper examples for web testing, web development, developing swing-based apppcations, the jdbc pbrary for connecting to MySQL databases. Following are just a couple of examples of few more pbraries.

data.xml

This pbrary allows Clojure to work with XML data. The pbrary 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 pbrary allows Clojure to work with JSON data. The pbrary version to be used is org.clojure/data.json "0.2.6".

Example

Following is an example on the use of this pbrary.

(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)