ddgo/example_test.go at master · metalagman/ddgo · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
package ddgo_test

import (
	"fmt"
	"log"

	"github.com/metalagman/ddgo"
)

func ExampleNew() {
	detector, err := ddgo.New()
	if err != nil {
		log.Fatalf("ddgo.New() failed: %v", err)
	}
	result, err := detector.Parse("Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0")
	if err != nil {
		log.Fatalf("Parse() failed: %v", err)
	}

	fmt.Printf("%s %s\n", result.Client.Name, result.Client.Version)
	// Output:
	// Firefox 124.0
}

func ExampleDetector_Parse() {
	detector, err := ddgo.New()
	if err != nil {
		log.Fatalf("ddgo.New() failed: %v", err)
	}
	result, err := detector.Parse("Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)")
	if err != nil {
		log.Fatalf("Parse() failed: %v", err)
	}

	fmt.Printf("is_bot=%t name=%s device=%s\n", result.Bot.IsBot, result.Bot.Name, result.Device.Type)
	// Output:
	// is_bot=true name=Googlebot device=Bot
}

func ExampleDetector_ParseWithClientHints() {
	detector, err := ddgo.New()
	if err != nil {
		log.Fatalf("ddgo.New() failed: %v", err)
	}
	mobile := true
	hints := ddgo.ClientHints{
		Brands:          []ddgo.ClientHintBrand{{Name: "Google Chrome", Version: "122.0.6261.128"}},
		Platform:        "Android",
		PlatformVersion: "14.0.0",
		Model:           "SM-G991B",
		Mobile:          &mobile,
	}

	result, err := detector.ParseWithClientHints("Mozilla/5.0", hints)
	if err != nil {
		log.Fatalf("ParseWithClientHints() failed: %v", err)
	}
	fmt.Printf("%s %s on %s (%s)\n", result.Client.Name, result.Client.Version, result.OS.Name, result.Device.Model)
	// Output:
	// Chrome 122.0.6261.128 on Android (SM-G991B)
}

func ExampleDetector_ParseWithHeaders() {
	detector, err := ddgo.New()
	if err != nil {
		log.Fatalf("ddgo.New() failed: %v", err)
	}
	headers := map[string]string{
		"Sec-CH-UA":                  "\"Not(A:Brand\";v=\"99\", \"Microsoft Edge\";v=\"123.0.0.0\", \"Chromium\";v=\"123.0.0.0\"",
		"Sec-CH-UA-Platform":         "\"Windows\"",
		"Sec-CH-UA-Platform-Version": "\"15.0.0\"",
		"Sec-CH-UA-Mobile":           "?0",
	}

	result, err := detector.ParseWithHeaders("Mozilla/5.0", headers)
	if err != nil {
		log.Fatalf("ParseWithHeaders() failed: %v", err)
	}
	fmt.Printf("%s %s (%s)\n", result.Client.Name, result.Client.Version, result.Device.Type)
	// Output:
	// Microsoft Edge 123.0.0.0 (Desktop)
}

func ExampleWithMaxUserAgentLen() {
	detector, err := ddgo.New(ddgo.WithMaxUserAgentLen(7))
	if err != nil {
		log.Fatalf("ddgo.New() failed: %v", err)
	}
	result, err := detector.Parse("Mozilla/5.0")
	if err != nil {
		log.Fatalf("Parse() failed: %v", err)
	}

	fmt.Println(result.UserAgent)
	// Output:
	// Mozilla
}

func ExampleWithUserAgentTrimming() {
	detector, err := ddgo.New(ddgo.WithUserAgentTrimming(false))
	if err != nil {
		log.Fatalf("ddgo.New() failed: %v", err)
	}
	result, err := detector.Parse("  Mozilla/5.0  ")
	if err != nil {
		log.Fatalf("Parse() failed: %v", err)
	}

	fmt.Printf("%q\n", result.UserAgent)
	// Output:
	// "  Mozilla/5.0  "
}

func ExampleParseClientHintsFromHeaders() {
	headers := map[string]string{
		"Sec-CH-UA-Full-Version-List": "\"Not A;Brand\";v=\"24\", \"Chromium\";v=\"122.0.6261.128\", \"Google Chrome\";v=\"122.0.6261.128\"",
		"Sec-CH-UA-Platform":          "\"Android\"",
		"Sec-CH-UA-Mobile":            "?1",
	}

	hints := ddgo.ParseClientHintsFromHeaders(headers)
	fmt.Printf("brands=%d platform=%s mobile=%t\n", len(hints.Brands), hints.Platform, *hints.Mobile)
	// Output:
	// brands=3 platform=Android mobile=true
}