Invariant Properties

package com.invariantproperties.sandbox.jira.example;

import static org.junit.Assert.assertEquals;

import java.io.IOException;
import java.net.URI;
import java.util.ResourceBundle;

import org.junit.Test;

import com.atlassian.jira.rest.client.api.IssueRestClient;
import com.atlassian.jira.rest.client.api.JiraRestClient;
import com.atlassian.jira.rest.client.api.domain.BasicIssue;
import com.atlassian.jira.rest.client.api.domain.Issue;
import com.atlassian.jira.rest.client.api.domain.IssueType;
import com.atlassian.jira.rest.client.api.domain.input.IssueInput;
import com.atlassian.jira.rest.client.api.domain.input.IssueInputBuilder;
import com.atlassian.jira.rest.client.internal.async.AsynchronousJiraRestClientFactory;

/**
 * Simple tests of Issue functionality.
 * 
 * @author Bear Giles 
 */
public class IssueTest {
    private static final ResourceBundle bundle = ResourceBundle.getBundle(IssueTest.class.getName());
    private static final URI serverUri = URI.create(bundle.getString("jiraUrl"));
    private static final String username = bundle.getString("username");
    private static final String password = bundle.getString("password");

    private static final String PROJECT_KEY = "TST";
    private static final long BUG_TYPE_ID = 1L; // JIRA magic value

    /**
     * Create an minimal issue, verify that we can retrieve it.
     */
    @Test
    public void createMinimalIssue() throws IOException {
        final JiraRestClient restClient = new AsynchronousJiraRestClientFactory().createWithBasicHttpAuthentication(
                serverUri, username, password);

        final IssueInputBuilder builder = new IssueInputBuilder(PROJECT_KEY, BUG_TYPE_ID, SUMMARY);
        final IssueInput input = builder.build();

        try {
            // create issue
            final IssueRestClient client = restClient.getIssueClient();
            final BasicIssue issue = client.createIssue(input).claim();

            assertNotNull(issue.getKey());

            // retrieve issue
            final Issue actual = client.getIssue(issue.getKey()).claim();

            assertEquals(PROJECT_KEY, actual.getProject().getKey());
            assertEquals(BUG_TYPE_ID, actual.getIssueType().getId().longValue());
            assertEquals(SUMMARY, actual.getSummary());

            // post 2.0.0-m25 we can delete issue to reduce clutter
            client.deleteIssue(issue.getKey(), false).claim();
        } finally {
            if (restClient != null) {
                restClient.close();
            }
        }
    }
}

public class IssueTest {
    private static final ResourceBundle bundle = ResourceBundle.getBundle(IssueTest.class.getName());
    private static final URI serverUri = URI.create(bundle.getString("jiraUrl"));
    private static final String username = bundle.getString("username");
    private static final String password = bundle.getString("password");

    private static final String PROJECT_KEY = "TST";
    private static final long TASK_TYPE_ID = 3L; // JIRA magic value
    private static final long SUBTASK_TYPE_ID = 5L; // JIRA magic value
    private static final String SUMMARY = "summary";

    /**
     * Create an minimal issue and subtask, verify that we can retrieve them.
     */
    @Test
    public void createMinimalIssueAndSubtask() throws IOException, JSONException {
        final JiraRestClient restClient = new AsynchronousJiraRestClientFactory().createWithBasicHttpAuthentication(
                serverUri, username, password);

        final IssueInputBuilder parentBuilder = new IssueInputBuilder(PROJECT_KEY, TASK_TYPE_ID, "parent");
        final IssueInput parentInput = parentBuilder.build();

        try {
            // create task
            final IssueRestClient client = restClient.getIssueClient();
            final BasicIssue parent = client.createIssue(parentInput).claim();

            assertNotNull(parent.getKey());
            System.out.println("parent: " + parent);

            // create subtask
            final IssueInputBuilder childBuilder = new IssueInputBuilder(PROJECT_KEY, SUBTASK_TYPE_ID, "child");
            childBuilder.setFieldValue("parent", ComplexIssueInputFieldValue.with("key", parent.getKey()));
            final BasicIssue child = client.createIssue(childBuilder.build()).claim();

            assertNotNull(child.getKey());

            // retrieve parent
            final Issue actual = client.getIssue(parent.getKey()).claim();

            assertEquals(PROJECT_KEY, actual.getProject().getKey());
            assertEquals("parent", actual.getSummary());

            // retrieve children, verify 'parent' points back to parent.
            for (final Subtask subtask : actual.getSubtasks()) {
                final Issue actualChild = client.getIssue(subtask.getIssueKey()).claim();
                final JSONObject json = (JSONObject) actualChild.getField("parent").getValue();
                assertEquals(parent.getKey(), json.getString("key"));
            }

            // post 2.0.0-m25 we can delete issue to reduce clutter
            client.deleteIssue(parent.getKey(), true).claim();
        } finally {
            if (restClient != null) {
                restClient.close();
            }
        }
    }
}

public class IssueTest {
    private static final ResourceBundle bundle = ResourceBundle.getBundle(IssueTest.class.getName());
    private static final URI serverUri = URI.create(bundle.getString("jiraUrl"));
    private static final String username = bundle.getString("username");
    private static final String password = bundle.getString("password");

    private static final String PROJECT_KEY = "TST";
    private static final long BUG_TYPE_ID = 1L; // JIRA magic value

    /**
     * Create an minimal issue, verify that we can search for it.
     */
    @Test
    public void createMinimalIssueAndSearch() throws IOException {
        final JiraRestClient restClient = new AsynchronousJiraRestClientFactory().createWithBasicHttpAuthentication(
                serverUri, username, password);

        final IssueInputBuilder builder = new IssueInputBuilder(PROJECT_KEY, BUG_TYPE_ID, SUMMARY);
        final IssueInput input = builder.build();

        try {
            // create issue
            final IssueRestClient issueClient = restClient.getIssueClient();
            final BasicIssue issue = issueClient.createIssue(input).claim();

            assertNotNull(issue.getKey());

            final SearchRestClient searchClient = restClient.getSearchClient();
            final String jql = "issuekey = \"" + issue.getKey() + "\"";
            final SearchResult results = searchClient.searchJql(jql).claim();
            assertEquals(1, results.getTotal());

            // retrieve results. We know there's only one.
            for (final Issue result : results.getIssues()) {
                final Issue actual = issueClient.getIssue(result.getKey()).claim();

                assertEquals(PROJECT_KEY, actual.getProject().getKey());
                assertEquals(BUG_TYPE_ID, actual.getIssueType().getId().longValue());
                assertEquals(SUMMARY, actual.getSummary());
            }

            // post 2.0.0-m25 we can delete issue to reduce clutter
            issueClient.deleteIssue(issue.getKey(), false).claim();
        } finally {
            if (restClient != null) {
                restClient.close();
            }
        }
    }
}

public class IssueTest {
    private static final ResourceBundle bundle = ResourceBundle.getBundle(IssueTest.class.getName());
    private static final URI serverUri = URI.create(bundle.getString("jiraUrl"));
    private static final String username = bundle.getString("username");
    private static final String password = bundle.getString("password");

    private static final String PROJECT_KEY = "TST";
    private static final long BUG_TYPE_ID = 1L; // JIRA magic value
    private static final String PRIORITY = "Trivial";
    private static final String DESCRIPTION = "description";
    private static final DateTime DUE_DATE = new DateTime();
    private static final String COLOR = "Red";

    /**
     * Create a simple issue, verify that we can retrieve it. This test requires
     * that a custom select field ("Color", key "customfield_10000") with
     * possible values of "Red", "Green" and "Blue" be created via the standard
     * web interface. It also requires the custom multi-select field
     * ("Toner Colors", key "customfield_10100") with possible values of
     * "Yellow", "Magenta", "Cyan", and "Black".
     * 
     * Implementation note: there are far more Issue getters than Builder
     * setters. This can be a bit confusing if you don't have a list of fields.
     */
    @Test
    public void createSimpleIssue() throws IOException, JSONException {
        final JiraRestClient restClient = new AsynchronousJiraRestClientFactory().createWithBasicHttpAuthentication(
                serverUri, username, password);

        final IssueInputBuilder builder = new IssueInputBuilder(PROJECT_KEY, BUG_TYPE_ID, SUMMARY);
        builder.setDescription(DESCRIPTION);
        builder.setDueDate(DUE_DATE);
        builder.setFieldValue("priority", ComplexIssueInputFieldValue.with("name", PRIORITY));
        // set single-select value
        builder.setFieldValue("customfield_10000", ComplexIssueInputFieldValue.with("value", COLOR));
        // set multi-select value
        builder.setFieldValue(
                "customfield_10100",
                Arrays.asList(ComplexIssueInputFieldValue.with("value", "Yellow"),
                        ComplexIssueInputFieldValue.with("value", "Black")));
        final IssueInput input = builder.build();

        try {
            // create issue
            final IssueRestClient client = restClient.getIssueClient();
            final BasicIssue issue = client.createIssue(input).claim();

            assertNotNull(issue.getKey());

            // retrieve issue
            final Issue actual = client.getIssue(issue.getKey()).claim();

            assertEquals(PROJECT_KEY, actual.getProject().getKey());
            assertEquals(BUG_TYPE_ID, actual.getIssueType().getId().longValue());
            assertEquals(SUMMARY, actual.getSummary());
            assertEquals(PRIORITY, actual.getPriority().getName());
            assertEquals(DESCRIPTION, actual.getDescription());

            // we can't check date because of timezone weirdness.
            // assertEquals(DUE_DATE, actual.getDueDate());

            // the 'value' of a custom field is actually a JSON object with the
            // fields (self, value, id).
            final JSONObject json = (JSONObject) actual.getField("customfield_10000").getValue();
            assertEquals(COLOR, json.getString("value"));

            // the value of a multiselect is a JSONArray of JSON objects.
            final JSONArray jarray = (JSONArray) actual.getField("customfield_10100").getValue();
            assertEquals("Yellow", ((JSONObject) jarray.get(0)).getString("value"));
            assertEquals("Black", ((JSONObject) jarray.get(1)).getString("value"));

            // we will be the 'reporter'
            final User user = restClient.getUserClient().getUser(bundle.getString("username")).claim();
            assertEquals(user, actual.getReporter());

            // in production the 'reporter' will probably not be the default
            // 'assignee' but it's another field we can check.
            assertEquals(user, actual.getAssignee());

            // post 2.0.0-m25 we can delete issue to reduce clutter
            client.deleteIssue(issue.getKey(), false).claim();
        } finally {
            if (restClient != null) {
                restClient.close();
            }
        }
    }
}

public class IssueTest {
    private static final ResourceBundle bundle = ResourceBundle.getBundle(IssueTest.class.getName());
    private static final URI serverUri = URI.create(bundle.getString("jiraUrl"));
    private static final String username = bundle.getString("username");
    private static final String password = bundle.getString("password");

    /**
     * Query for creation metadata - this tells is the possible values for issue
     * type, priority, and resolution. It also tells us the name and type of
     * standard and custom fields.
     */
    // @Test
    public void learnCreateMetadata() throws IOException {
        final JiraRestClient restClient = new AsynchronousJiraRestClientFactory().createWithBasicHttpAuthentication(
                serverUri, username, password);

        try {
            final MetadataRestClient client = restClient.getMetadataClient();

            // list issue types
            System.out.println("issue types:");
            for (IssueType type : client.getIssueTypes().claim()) {
                System.out.printf("- %s (%d): %s\n", type.getName(), type.getId(), type.getDescription());
            }
            System.out.println();

            System.out.println("priorities");
            for (Priority priority : client.getPriorities().claim()) {
                System.out.printf("- %s (%d): %s\n", priority.getName(), priority.getId(), priority.getDescription());
            }
            System.out.println();

            System.out.println("resolutions");
            for (Resolution resolution : client.getResolutions().claim()) {
                System.out.printf("- %s: %s\n", resolution.getName(), resolution.getDescription());
            }
            System.out.println();

            System.out.println("jira fields");
            for (Field field : client.getFields().claim()) {
                if (FieldType.JIRA.equals(field.getFieldType())) {
                    System.out.printf("- %s (%s) %s\n", field.getName(), field.getId(),
                            (field.getSchema() != null) ? field.getSchema().getType() : "(not specified)");
                }
            }
            System.out.println();

            // we can get possible values with
            // http://localhost:8080/rest/api/2/issue/createmeta?expand=projects.issuetypes.fields
            // but there's no JRJC for that (yet).
            System.out.println("custom fields");
            for (Field field : client.getFields().claim()) {
                if (FieldType.CUSTOM.equals(field.getFieldType())) {
                    System.out.printf("- %s (%s) %s\n", field.getName(), field.getId(),
                            (field.getSchema() != null) ? field.getSchema().getType() : "(not specified)");
                }
            }
        } finally {
            if (restClient != null) {
                restClient.close();
            }
        }
    }
}