Add opt package

Author: hioki-daichi

kadai3-2/hioki-daichi/opt/opt.go

@@ -0,0 +1,56 @@
+/*
+Package opt deals with CLI options.
+*/
+package opt
+
+import (
+	"errors"
+	"flag"
+	"net/url"
+	"path"
+	"time"
+)
+
+var errExist = errors.New("file already exists")
+
+// Options has the options required for parallel-download.
+type Options struct {
+	Parallelism int
+	Output      string
+	URL         *url.URL
+	Timeout     time.Duration
+}
+
+// Parse parses args and returns Options.
+func Parse(args ...string) (*Options, error) {
+	flg := flag.NewFlagSet("parallel-download", flag.ExitOnError)
+
+	parallelism := flg.Int("p", 8, "Download files in parallel according to the specified number.")
+	output := flg.String("o", "", "Save the downloaded file in the specified path. (Overwrite if duplicates.)")
+	timeout := flg.Duration("t", 30*time.Second, "Terminate when the specified value has elapsed since download started.")
+
+	flg.Parse(args)
+
+	u, err := url.ParseRequestURI(flg.Arg(0))
+	if err != nil {
+		return nil, err
+	}
+
+	if *output == "" {
+		_, filename := path.Split(u.Path)
+
+		// Inspired by the --default-page option of wget
+		if filename == "" {
+			filename = "index.html"
+		}
+
+		*output = filename
+	}
+
+	return &Options{
+		Parallelism: *parallelism,
+		Output:      *output,
+		URL:         u,
+		Timeout:     *timeout,
+	}, nil
+}

kadai3-2/hioki-daichi/opt/opt_test.go

@@ -0,0 +1,71 @@
+package opt
+
+import (
+	"net/url"
+	"reflect"
+	"testing"
+)
+
+func TestMain_parse(t *testing.T) {
+	cases := map[string]struct {
+		args                []string
+		expectedParallelism int
+		expectedOutput      string
+		expectedURLString   string
+	}{
+		"no options": {args: []string{"http://example.com/foo.png"}, expectedParallelism: 8, expectedOutput: "foo.png", expectedURLString: "http://example.com/foo.png"},
+		"-p=2":       {args: []string{"-p=2", "http://example.com/foo.png"}, expectedParallelism: 2, expectedOutput: "foo.png", expectedURLString: "http://example.com/foo.png"},
+		"-o=bar.png": {args: []string{"-o=bar.png", "http://example.com/foo.png"}, expectedParallelism: 8, expectedOutput: "bar.png", expectedURLString: "http://example.com/foo.png"},
+		"index.html": {args: []string{"http://example.com/"}, expectedParallelism: 8, expectedOutput: "index.html", expectedURLString: "http://example.com/"},
+	}
+
+	for n, c := range cases {
+		c := c
+		t.Run(n, func(t *testing.T) {
+			args := c.args
+			expectedParallelism := c.expectedParallelism
+			expectedOutput := c.expectedOutput
+			expectedURL, err := url.ParseRequestURI(c.expectedURLString)
+			if err != nil {
+				t.Fatalf("err %s", err)
+			}
+
+			opts, err := Parse(args...)
+			if err != nil {
+				t.Fatalf("err %s", err)
+			}
+
+			actualParallelism := opts.Parallelism
+			actualOutput := opts.Output
+			actualURL := opts.URL
+
+			if actualParallelism != expectedParallelism {
+				t.Errorf(`unexpected parallelism: expected: %d actual: %d`, expectedParallelism, actualParallelism)
+			}
+
+			if actualOutput != expectedOutput {
+				t.Errorf(`unexpected output: expected: "%s" actual: "%s"`, expectedOutput, actualOutput)
+			}
+
+			if !reflect.DeepEqual(actualURL, expectedURL) {
+				t.Errorf(`unexpected URL: expected: "%s" actual: "%s"`, expectedURL, actualURL)
+			}
+		})
+	}
+}
+
+func TestMain_parse_InvalidURL(t *testing.T) {
+	t.Parallel()
+
+	expected := "parse %: invalid URI for request"
+
+	_, err := Parse([]string{"%"}...)
+	if err == nil {
+		t.Fatal("Unexpectedly err was nil")
+	}
+
+	actual := err.Error()
+	if actual != expected {
+		t.Errorf(`unexpected error: expected: "%s" actual: "%s"`, expected, actual)
+	}
+}