n this sprint, the goal is to implement a first release of an online shop with the following functional features: * Management of a product (from the exercises) * Creation of orders with products from the catalogue
The scenarios to be implemented are specified using Gherkin notation in Order.feature. A demo of how these scenarios should be implemented is available at the beginning of this :movie_camera: lecture.
Summary of steps for working on the mini project
Watch the demo of the system given at the beginning of :movie_camera: this lecture(minute 1:40)
The code of the part of the demo that is not assessed (product management) has been provided as an example: :computer: source code is here and it can be reused for your mini project
you are not going to get any marks for this code
but the code should a useful starting point
To the develop the web app of the mini project, you need to
set up your project infrastucture as in project SpringMvc_product
develop the following parts:
views (JSP files)
domain classes (Java classes)
controller classes (Java classes)
Software development is carried out in an iterative way in small increments:
first iteration:
develop a smoke test: develop a simple controller and get it to respond to a GET http request (e.g. http://localhost:8090/product/) by showing a view (on a browser)
subsequent iterations:
once this is working, add more contents to the view and controller (and domain classes)
run your application and check that it is working as expected
a good way to get used to this process is by doing the exercises before doing the mini project
for each iteration that results in working software, push a commit to your repo
Where to start?
In order to guide you through the development of the system, you can use the following priorities:
start by developing the creation of an order
continue by developing the addition of an item
develop update/deletion of orders
develop update/deletion of order items
Please use the following names for your requests in order to ensure a smooth implementation of features during the last week of the sprint:
button (action) url view containing button resulting view
show orders “/order/” “index” “form/orderMaster”
add order “/order/add/” “form/orderMaster” “form/orderDetail”
delete order “/order/delete/” “form/orderMaster” “form/orderMaster”
show details of item with id 0 in order with id 0 “/item/detail?orderId=0&itemId=0” “form/orderDetail” “form/itemDetail”
delete item with id 0 (from order with id 0) “/item/delete?orderId=0&itemId=0” “form/orderDetail” “form/orderDetail”
add/edit item with id 0, within order with id 0, with product with id 0 and amount 4 “/item/add?orderId=0&itemId=0&productId=0&amount=4” “form/itemDetail” “form/orderDetail”
Considerations about the mini project
When developing the mini project take into account that: * Some aspects of the mini project will follow quite straigthforwardly from the exercises and there are other aspects that are designed to challenge you. * Use your software development skills acquired during your first year and during your second year in order to make design decisions, regarding * the number of classes that you need to include * suitable combinations of techniques * for example: the development of the drop-down list of products in the itemDetail.jsp view requires combining traversals of lists of products in JSTL together the use of the spring form tags select and option. * solving this example requires browsing documentation and looking at examples (in the references provided, on the internet, etc)
Help! I’m stuck!
Use the discussion board on Blackboard
Use office hours/TA help desk hours
Marking criteria
Implementation and testing of functional features (78 marks)
In the following table, you will find a classification of features according to their priority in order to guide their development: @should scenarios should be implemented before @couldscenarios (although this is only a recommendation).
Scenario Priority Marks for development Marks for testing Total
Order.Navigation.Get @should 9 9 18
Order.Logic.Create @should 3 3 6
Order.Logic.Delete @should 3 3 6
Item.Navigation.Post @could 3 3 6
Item.Navigation.Get @could 6 6 12
Item.Logic.Create @should 3 3 6
Item.Logic.Create.Exception @could 3 3 6
Item.Logic.Edit @could 3 3 6
Item.Logic.Edit.Exception @could 3 3 6
Item.Logic.Delete @could 3 3 6
Marking guidelines: each scenario is marked out of 3 marks twice (first for assessing the implementation using Spring MVC, and the second time to assess the testing aspect, using SpringMvc Test, Cucumber and HamCrest). Each implementation and testing aspect of a scenario is marked as follows: * 1: code does not compile but there is an thoughtful attempt at implementing the scenarios. * 2: code does compile but contains errors (e.g. it is not testing what it should test). Code is readable. Some functionality from the frameworks and libraries (SpringMvc, SpringMvc Test, HamCrest) are not used correctly. * 3: code is fit for purpose and is well documented (and readable). Excellent use of frameworks and libraries (SpringMvc, SpringMvc Test, HamCrest).
JSP Views (15 marks)
Each view is worth 5 marks * orderMaster.jsp: view with the complete list of orders showing their details as in the demo (including a brief summary of products involved and the total cost) with the following actions: add, edit and delete specific orders. * orderDetail.jsp: view with the details of a given order, listing all of its items, including: product (name, description, price), amount and cost. It should include the following actions: add, edit and delete order items. * itemDetail.jsp: view the details of a specific order item, showing the product involved and the amount required. It should provide the following actions: * choosing a product from the catalogue; * adding an item to an order.
Marking guidelines: * 1-2: views are not working although there is an attempt at implementing them with the expression language and with EL. * 2-3: readable JSPs, with the presence of some bugs. The expression language EL is used to fetch information from the model mostly correctly and JSTL and Spring tag libraries are used.
* 4-5: well documented, readable JSPs, work perfectly well using the expression language to fetch information from the model and using JSTL to generate structured HTML. Proper use of JSTL and Spring tag libraries.
Engagement and release procedure (7 marks)
Performance monitoring (4 marks)
We are going to practise agile principles by using the following intermediate checkpoints in order to simulate weekly sprints resulting in small increments to your mini project: * checkpoint 1: Monday 31 October (midnight) * initial executable skeleton (e.g. the code in the project SpringMvc_product) of your mini project pushed to your individual repo under root/sprint2/mini-project/ * executable means that ./gradlew bootRunshould start your application correctly * your gradle build script must be located at root/sprint2/mini-project/gradle.build where root refers to the actual root directory of your git repository (the directory that contains the directory .git) * clone your repository in a new workspace and check that root/sprint2/mini-project/gradlew bootRun does work * checkpoint 2: Wednesday 9 November, 9am * substantial progress made with respect to functionality (ideally 90% complete or more) corresponding to the demo given at the beginning of :movie_camera: this lecture (minute 1:40) * code developed must be executable and should be pushed to your private repo as done for the previous checkpoint * release of Sprint 2: Wednesday 16 November, 9am 23:59 (see below for further details) * full implementation of prototype * full implementation of tests
Release: submission procedure (3 marks)
Commit and push your mini project (the whole project) to your GitHub repository, under the folder root/sprint2/mini-project so that you can find your file gradle.build in root/sprint2/mini-project/gradle.build
Make a release on GitHub
Open the repo in Github
Click Releases
Click Create a new release
Enter the Tag Version as ws1 (leave @ Target Master)
Enter the Release Title as Worksheet 1 submission
Click Publish Release
Clone your repository in a new workspace and check that root/sprint2/mini-project/gradlew check generates a report in folder root/sprint2/mini-project/build/cucumber-html-report/index.html