text stringlengths 11 4.05M |
|---|
package omokServer
import (
"scommon"
"smallNet"
"time"
)
func (svr *Server) Process_goroutine() {
scommon.LogInfo("[Process_goroutine] Start")
timeTicker := time.NewTicker(time.Millisecond * 100)
defer timeTicker.Stop()
defer svr._serverNet.Stop()
LOOP:
for {
select {
case _ = <-timeTicker.C:
svr._userMgr.checkUserState()
case netMsg := <-svr._serverNet.GetNetMsg():
svr.processNetMsg(netMsg)
case <-svr._onStopNetMsgProcess:
break LOOP
}
}
scommon.LogInfo("[Process_goroutine] End")
}
func (svr *Server) processNetMsg(netMsg smallNet.NetMsg) {
msg := svr._serverNet.PrepareNetMsg(netMsg)
switch msg.Type {
case smallNet.NetMsg_Receive:
scommon.LogDebug("OnReceive")
svr.packetProcess(msg.SessionIndex, msg.Data)
case smallNet.NetMsg_Connect:
scommon.LogDebug("OnConnect")
conf := userConf{
heartbeatReqIntervalTimeMSec: int64(svr.conf.HeartbeatReqIntervalTimeMSec),
heartbeatWaitTimeMSec: int64(svr.conf.HeartbeatWaitTimeMSec),
}
svr._userMgr.addUser(msg.SessionIndex, conf)
case smallNet.NetMsg_Close:
scommon.LogDebug("OnClose")
svr._userMgr.removeUser(msg.SessionIndex)
default:
scommon.LogDebug("[Process_goroutine] none")
}
}
|
package home
import (
"github.com/gin-gonic/gin"
"github.com/spf13/viper"
"net/http"
)
func Index(c *gin.Context) {
data := gin.H{
"title": "首页",
"httpUrl": viper.GetString("app.httpUrl"),
"webSocketUrl": viper.GetString("app.webSocketUrl"),
}
c.HTML(http.StatusOK, "index.html", data)
}
|
package main
import (
"encoding/json"
"fmt"
"net/http"
"strconv"
"time"
"github.com/gorilla/mux"
"github.com/jinzhu/gorm"
)
type Article struct {
ID int
ArticleWriter string
PostedAt time.Time
UpdatedAt time.Time
ArticleWriterEmail string
}
const dbPath string = "your-database-path"
func ConnectDB() *gorm.DB {
db, err := gorm.Open("sqlite3", dbPath)
if err != nil {
panic("failed to connect to database")
}
return db
}
func welcomeToWebsite(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Welcome to my website")
}
func GetArticles(w http.ResponseWriter, r *http.Request) {
db := ConnectDB()
defer db.Close()
var Articles []Article
db.Find(&Articles)
json.NewEncoder(w).Encode(Articles)
}
func AddNewArticle(w http.ResponseWriter, r *http.Request) {
db := ConnectDB()
defer db.Close()
parameters := mux.Vars(r)
name := parameters["name"]
id, _ := strconv.Atoi(parameters["id"])
email := parameters["email"]
db.Create(Article{ArticleWriter: name, ID: id, ArticleWriterEmail: email})
fmt.Fprintf(w, "New user created")
}
func UpdateArticle(w http.ResponseWriter, r *http.Request) {
db := ConnectDB()
defer db.Close()
parameters := mux.Vars(r)
id, _ := strconv.Atoi(parameters["id"])
email := parameters["email"]
var article Article
db.Where("id = ?", id).Find(&article)
article.ArticleWriterEmail = email
db.Save(&article)
fmt.Fprintf(w, "user information udated")
}
func DeleteArticle(w http.ResponseWriter, r *http.Request) {
db := ConnectDB()
defer db.Close()
parameters := mux.Vars(r)
id, _ := strconv.Atoi(parameters["id"])
var article Article
db.Where("id = ?", id).Find(&article)
db.Delete(&article)
fmt.Fprintf(w, "user deleted")
}
func httpRequests() {
router := mux.NewRouter().StrictSlash(true)
router.HandleFunc("/", welcomeToWebsite).Methods("GET")
router.HandleFunc("/api/articles", GetArticles).Methods("GET")
router.HandleFunc("/api/new_article/{id}/{name}/{email}", AddNewArticle).Methods("POST")
router.HandleFunc("/api/update_article/{id}/{email}", UpdateArticle).Methods("PUT")
router.HandleFunc("/api/delete_article/{id}", DeleteArticle).Methods("DELETE")
http.ListenAndServe(":8080", router)
}
func main() {
db := ConnectDB()
db.AutoMigrate(&Article{})
defer db.Close()
httpRequests()
}
|
package main
import (
"fmt"
"log"
"net/http"
"strings"
"time"
"github.com/gorilla/websocket"
"github.com/westphae/magkal/pkg/kalman"
)
type source int // Source is where the measurements come from
const (
manual source = iota // User sends measurements through websocket
random // Measurements are made randomly
file // Measurements come from a file
actual // Measurements come from an actual MPU sensor
)
type params struct {
Source source `json:"source"` // Source of the magnetometer data
N int `json:"n"` // Number of dimensions
N0 float64 `json:"n0"` // Value of Earth's magnetic field at location
KAct *[]float64 `json:"kAct"` // Actual K for manual, random measurement sources
LAct *[]float64 `json:"lAct"` // Actual L for manual, random measurement sources
SigmaK0 float64 `json:"sigmaK0"` // Initial noise scale for k
SigmaK float64 `json:"sigmaK"` // Process noise scale for k
SigmaM float64 `json:"sigmaM"` // Noise scale for measurement
}
// Some sensible default parameters to start the user off
var defaultParams = params{
manual, 3, 10000.0,
&[]float64{0.8, 0.7, 0.9}, &[]float64{1980, 1500, -1776},
0.25, 0.00000001, 0.05,
}
type measureCmd struct {
A direction `json:"a"` // Raw measurement (for manual), pre-noise
}
type estimateCmd struct {
NN float64 `json:"nn"` // The actual measurement of N^2
}
type messageIn struct {
Params *params `json:"params"` // if the messageIn contains new params
Measure *measureCmd `json:"measure"` // if the messageIn contains a measurement command
Estimate *estimateCmd `json:"estimate"` // if the messageIn contains an estimate command
}
type state struct {
K []float64 `json:"k"` // Current estimate of K
L []float64 `json:"l"` // Current estimate of L
P [][]float64 `json:"p"` // Current estimate of P, uncertainty matrix of state
}
type messageOut struct {
Params *params `json:"params"` // The params the server is using
Measurement *measurement `json:"measurement"` // A raw measurement from the magnetometer source
State *state `json:"state"` // Current state of the system
}
func (s state) String() string {
var r strings.Builder
r.WriteString("K: [")
for i := 0; i < len(s.K); i++ {
r.WriteString(fmt.Sprintf("%12.3g", (s.K)[i]))
if i < len(s.K)-1 {
r.WriteString(" ")
}
}
r.WriteString("]\nL: [")
for i := 0; i < len(s.K); i++ {
r.WriteString(fmt.Sprintf("%12.3g", (s.L)[i]))
if i < len(s.K)-1 {
r.WriteString(" ")
}
}
r.WriteString("]\nP: [")
for i := 0; i < len(s.K); i++ {
r.WriteString("[")
for j := 0; j < len(s.K); j++ {
r.WriteString(fmt.Sprintf("%12.3g", (s.P)[i][j]))
if j < len(s.K)-1 {
r.WriteString(" ")
}
}
r.WriteString("]")
if i < len(s.K)-1 {
r.WriteString("\n ")
}
}
r.WriteString("]")
return r.String()
}
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
CheckOrigin: func(r *http.Request) bool { return true },
}
func main() {
fs := http.FileServer(http.Dir("www"))
http.Handle("/", fs)
http.HandleFunc("/websocket", handleConnections)
log.Println("Listening for connections on port 8000")
log.Fatal(http.ListenAndServe(":8000", nil))
}
func handleConnections(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Printf("Error upgrading to websocket: %s\n", err)
return
}
defer func() {
if err := conn.Close(); err != nil {
log.Printf("Error closing websocket: %s\n", err.Error())
}
}()
log.Println("A client opened a connection")
// Handle ping-pong
var timeout *time.Timer
go func() {
pingTime := time.NewTicker(5 * time.Second)
for {
if err = conn.WriteControl(websocket.PingMessage, []byte("ping"), time.Now().Add(10*time.Second)); err != nil {
log.Printf("ws error sending ping: %s\n", err)
break
}
timeout = time.NewTimer(10 * time.Second)
select {
case <-pingTime.C:
timeout.Stop()
case <-timeout.C:
log.Println("ping timeout")
pingTime.Stop()
if err = conn.Close(); err != nil {
log.Printf("Error closing connection: %s\n", err)
}
break
}
}
log.Println("Stopping ping")
}()
conn.SetPongHandler(func(appData string) error {
timeout.Stop()
return nil
})
// Read messages from the client and receive control messages
/*
1. Receive websocket message, determine type
2. If type is params:
a. stop/close any current sim (send a nil measurement)
b. initialize a new sim
c. send reset command to client
3. If type is measure:
a. create a measurement according to source
b. send to filter
c. send result to client
*/
var (
msgIn messageIn
msgOut messageOut
cmd measureCmd
myMeasurement measurement
myParams = defaultParams
myMeasurer, _ = makeManualMeasurer(myParams.N, myParams.N0, *myParams.KAct, *myParams.LAct, myParams.N0*myParams.SigmaM)
myEstimator = kalman.NewKalmanFilter(myParams.N, myParams.N0, myParams.SigmaK0, myParams.SigmaK, myParams.SigmaM)
)
// Send initial params
msgOut = messageOut{
&myParams,
nil,
&state{
K: myEstimator.K(),
L: myEstimator.L(),
P: myEstimator.P(),
},
}
if err = conn.WriteJSON(msgOut); err != nil {
log.Printf("Error writing params to websocket: %s\n", err)
return
}
msgOut.Params = nil
log.Println("Listening for messages from a new client")
for {
if err = conn.ReadJSON(&msgIn); err != nil {
log.Printf("Error reading from websocket: %s\n", err)
break
}
timeout.Stop() // Stop the timeout if we get a message, not just a pong
// Extract any new parameters
if msgIn.Params != nil {
myParams = *msgIn.Params
msgIn.Params = nil
msgOut.Params = &myParams
log.Printf("Received params %v\n", myParams)
switch myParams.Source {
case manual:
myMeasurer, _ = makeManualMeasurer(myParams.N, myParams.N0, *myParams.KAct, *myParams.LAct, myParams.N0*myParams.SigmaM)
log.Println("Set Manual measurer")
case random:
myMeasurer, _ = makeRandomMeasurer(myParams.N, myParams.N0, *myParams.KAct, *myParams.LAct, myParams.N0*myParams.SigmaM)
log.Println("Set Random measurer")
case actual:
/*
myParams.N = 3
myMeasurer, err = makeActualMeasurer()
if err != nil {
log.Printf("Error connecting to MPU: %s, setting Random measurer\n", err)
myMeasurer, _ = makeManualMeasurer(myParams.N, myParams.N0, *myParams.KAct, *myParams.LAct, myParams.N0*myParams.SigmaM)
}
*/
case file: // TODO: implement
default:
myMeasurer, _ = makeManualMeasurer(myParams.N, myParams.N0, *myParams.KAct, *myParams.LAct, myParams.N0*myParams.SigmaM)
log.Printf("Received bad source: %d, setting Manual measurer\n", myParams.Source)
break
}
myEstimator = kalman.NewKalmanFilter(myParams.N, myParams.N0, myParams.SigmaK0, myParams.SigmaK, myParams.SigmaM)
msgOut.State = &state{
K: myEstimator.K(),
L: myEstimator.L(),
P: myEstimator.P(),
}
log.Printf("Sending params %v and initial state\n", myParams)
}
// Return any requested measurements
if msgIn.Measure != nil {
cmd = *msgIn.Measure
msgIn.Measure = nil
log.Printf("Received raw measurement %v\n", cmd)
myMeasurement = myMeasurer(cmd.A)
msgOut.Measurement = &myMeasurement
log.Printf("Sending measurement %v\n", myMeasurement)
}
// Perform any state estimations with the Kalman Filter
if msgIn.Estimate != nil {
nn := msgIn.Estimate.NN
msgIn.Estimate = nil
log.Printf("Estimating: %3.1f\n", nn)
myEstimator.U <- kalman.Matrix{myMeasurement}
myEstimator.Z <- nn
msgOut.State = &state{
K: myEstimator.K(),
L: myEstimator.L(),
P: myEstimator.P(),
}
log.Println("Sending state:")
log.Printf("K: %v\n", msgOut.State.K)
log.Printf("L: %v\n", msgOut.State.L)
log.Printf("P: %v\n", msgOut.State.P)
}
// Return message and clean up
if err = conn.WriteJSON(msgOut); err != nil {
log.Printf("Error writing to websocket: %s\n", err)
}
msgOut.Params = nil
msgOut.Measurement = nil
msgOut.State = nil
}
log.Println("Closing client")
}
|
// DO NOT EDIT. This file was generated by "github.com/frk/gosql".
package testdata
import (
"github.com/frk/gosql"
)
func (q *InsertDefaultAllSingleQuery) Exec(c gosql.Conn) error {
const queryString = `INSERT INTO "test_user_with_defaults" AS u (
"email"
, "full_name"
, "is_active"
, "created_at"
, "updated_at"
) VALUES (
DEFAULT
, DEFAULT
, DEFAULT
, DEFAULT
, DEFAULT
)` // `
_, err := c.Exec(queryString)
return err
}
|
package cmd
import (
"00-newapp-template/internal/app/cmd/client"
"00-newapp-template/internal/pkg"
"00-newapp-template/internal/pkg/adapter"
"00-newapp-template/internal/pkg/ui"
"fmt"
"github.com/spf13/cobra"
)
// Client is the dispactcher from Cobra to Config
type Client struct {
Config *pkg.Config
Adapter *adapter.Adapter
CLI ui.CLI
}
// NewClient dispatches from cobra commands
func NewClient(config *pkg.Config) (c Client) {
c.Config = config
c.CLI = ui.NewCLI(config)
c.Adapter = adapter.NewAdapter(c.Config)
return
}
// Client default action is to show help
func (c *Client) Client(cmd *cobra.Command, args []string) {
cmd.Help()
return
}
// List command
func (c *Client) List(cmd *cobra.Command, args []string) {
client.List(c.Adapter, c.CLI)
return
}
// Delete command
func (c *Client) Delete(cmd *cobra.Command, args []string) {
client.Delete(c.Adapter, c.CLI)
return
}
// Update command
func (c *Client) Update(cmd *cobra.Command, args []string) {
fmt.Printf("UpdateCommand\n")
return
}
|
package machines
import (
"testing"
"github.com/stretchr/testify/assert"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/utils/pointer"
"github.com/openshift/installer/pkg/asset"
"github.com/openshift/installer/pkg/asset/ignition/machine"
"github.com/openshift/installer/pkg/asset/installconfig"
"github.com/openshift/installer/pkg/asset/rhcos"
"github.com/openshift/installer/pkg/types"
awstypes "github.com/openshift/installer/pkg/types/aws"
)
func TestWorkerGenerate(t *testing.T) {
cases := []struct {
name string
key string
hyperthreading types.HyperthreadingMode
expectedMachineConfig []string
}{
{
name: "no key hyperthreading enabled",
hyperthreading: types.HyperthreadingEnabled,
},
{
name: "key present hyperthreading enabled",
key: "ssh-rsa: dummy-key",
hyperthreading: types.HyperthreadingEnabled,
expectedMachineConfig: []string{`apiVersion: machineconfiguration.openshift.io/v1
kind: MachineConfig
metadata:
creationTimestamp: null
labels:
machineconfiguration.openshift.io/role: worker
name: 99-worker-ssh
spec:
config:
ignition:
version: 3.2.0
passwd:
users:
- name: core
sshAuthorizedKeys:
- 'ssh-rsa: dummy-key'
extensions: null
fips: false
kernelArguments: null
kernelType: ""
osImageURL: ""
`},
},
{
name: "no key hyperthreading disabled",
hyperthreading: types.HyperthreadingDisabled,
expectedMachineConfig: []string{`apiVersion: machineconfiguration.openshift.io/v1
kind: MachineConfig
metadata:
creationTimestamp: null
labels:
machineconfiguration.openshift.io/role: worker
name: 99-worker-disable-hyperthreading
spec:
config:
ignition:
version: 3.2.0
extensions: null
fips: false
kernelArguments:
- nosmt
kernelType: ""
osImageURL: ""
`},
},
{
name: "key present hyperthreading disabled",
key: "ssh-rsa: dummy-key",
hyperthreading: types.HyperthreadingDisabled,
expectedMachineConfig: []string{`apiVersion: machineconfiguration.openshift.io/v1
kind: MachineConfig
metadata:
creationTimestamp: null
labels:
machineconfiguration.openshift.io/role: worker
name: 99-worker-disable-hyperthreading
spec:
config:
ignition:
version: 3.2.0
extensions: null
fips: false
kernelArguments:
- nosmt
kernelType: ""
osImageURL: ""
`, `apiVersion: machineconfiguration.openshift.io/v1
kind: MachineConfig
metadata:
creationTimestamp: null
labels:
machineconfiguration.openshift.io/role: worker
name: 99-worker-ssh
spec:
config:
ignition:
version: 3.2.0
passwd:
users:
- name: core
sshAuthorizedKeys:
- 'ssh-rsa: dummy-key'
extensions: null
fips: false
kernelArguments: null
kernelType: ""
osImageURL: ""
`},
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
parents := asset.Parents{}
parents.Add(
&installconfig.ClusterID{
UUID: "test-uuid",
InfraID: "test-infra-id",
},
installconfig.MakeAsset(
&types.InstallConfig{
ObjectMeta: metav1.ObjectMeta{
Name: "test-cluster",
},
SSHKey: tc.key,
BaseDomain: "test-domain",
Platform: types.Platform{
AWS: &awstypes.Platform{
Region: "us-east-1",
},
},
Compute: []types.MachinePool{
{
Replicas: pointer.Int64Ptr(1),
Hyperthreading: tc.hyperthreading,
Platform: types.MachinePoolPlatform{
AWS: &awstypes.MachinePool{
Zones: []string{"us-east-1a"},
InstanceType: "m5.large",
},
},
},
},
}),
(*rhcos.Image)(pointer.StringPtr("test-image")),
(*rhcos.Release)(pointer.StringPtr("412.86.202208101040-0")),
&machine.Worker{
File: &asset.File{
Filename: "worker-ignition",
Data: []byte("test-ignition"),
},
},
)
worker := &Worker{}
if err := worker.Generate(parents); err != nil {
t.Fatalf("failed to generate worker machines: %v", err)
}
expectedLen := len(tc.expectedMachineConfig)
if assert.Equal(t, expectedLen, len(worker.MachineConfigFiles)) {
for i := 0; i < expectedLen; i++ {
assert.Equal(t, tc.expectedMachineConfig[i], string(worker.MachineConfigFiles[i].Data), "unexepcted machine config contents")
}
} else {
assert.Equal(t, 0, len(worker.MachineConfigFiles), "expected no machine config files")
}
})
}
}
func TestComputeIsNotModified(t *testing.T) {
parents := asset.Parents{}
installConfig := installconfig.MakeAsset(
&types.InstallConfig{
ObjectMeta: metav1.ObjectMeta{
Name: "test-cluster",
},
SSHKey: "ssh-rsa: dummy-key",
BaseDomain: "test-domain",
Platform: types.Platform{
AWS: &awstypes.Platform{
Region: "us-east-1",
DefaultMachinePlatform: &awstypes.MachinePool{
InstanceType: "TEST_INSTANCE_TYPE",
},
},
},
Compute: []types.MachinePool{
{
Replicas: pointer.Int64Ptr(1),
Hyperthreading: types.HyperthreadingDisabled,
Platform: types.MachinePoolPlatform{
AWS: &awstypes.MachinePool{
Zones: []string{"us-east-1a"},
InstanceType: "",
},
},
},
},
})
parents.Add(
&installconfig.ClusterID{
UUID: "test-uuid",
InfraID: "test-infra-id",
},
installConfig,
(*rhcos.Image)(pointer.StringPtr("test-image")),
(*rhcos.Release)(pointer.StringPtr("412.86.202208101040-0")),
&machine.Worker{
File: &asset.File{
Filename: "worker-ignition",
Data: []byte("test-ignition"),
},
},
)
worker := &Worker{}
if err := worker.Generate(parents); err != nil {
t.Fatalf("failed to generate master machines: %v", err)
}
if installConfig.Config.Compute[0].Platform.AWS.Type != "" {
t.Fatalf("compute in the install config has been modified")
}
}
func TestDefaultAWSMachinePoolPlatform(t *testing.T) {
type testCase struct {
name string
poolName string
expectedMachinePool awstypes.MachinePool
assert func(tc *testCase)
}
cases := []testCase{
{
name: "default EBS type for compute pool",
poolName: types.MachinePoolComputeRoleName,
expectedMachinePool: awstypes.MachinePool{
EC2RootVolume: awstypes.EC2RootVolume{
Type: awstypes.VolumeTypeGp3,
Size: decimalRootVolumeSize,
},
},
assert: func(tc *testCase) {
mp := defaultAWSMachinePoolPlatform(tc.poolName)
want := tc.expectedMachinePool.EC2RootVolume.Type
got := mp.EC2RootVolume.Type
assert.Equal(t, want, got, "unexepcted EBS type")
},
},
{
name: "default EBS type for edge pool",
poolName: types.MachinePoolEdgeRoleName,
expectedMachinePool: awstypes.MachinePool{
EC2RootVolume: awstypes.EC2RootVolume{
Type: awstypes.VolumeTypeGp2,
Size: decimalRootVolumeSize,
},
},
assert: func(tc *testCase) {
mp := defaultAWSMachinePoolPlatform(tc.poolName)
want := tc.expectedMachinePool.EC2RootVolume.Type
got := mp.EC2RootVolume.Type
assert.Equal(t, want, got, "unexepcted EBS type")
},
},
}
for i := range cases {
tc := cases[i]
t.Run(tc.name, func(t *testing.T) {
tc.assert(&tc)
})
}
}
|
// Copyright Jetstack Ltd. See LICENSE for details.
package cmd
import (
"fmt"
"os"
"path/filepath"
"github.com/hashicorp/go-multierror"
vault "github.com/hashicorp/vault/api"
"github.com/sirupsen/logrus"
"github.com/spf13/cobra"
"github.com/jetstack/vault-helper/pkg/instanceToken"
)
// RootCmd represents the base command when called without any subcommands
var RootCmd = &cobra.Command{
Use: "vault-helper",
Short: "Automates PKI tasks using Hashicorp's Vault as a backend.",
}
var Must = func(err error) {
if err != nil {
logrus.Fatal(err)
}
}
// Execute adds all child commands to the root command sets flags appropriately.
// This is called by main.main(). It only needs to happen once to the rootCmd.
func Execute() {
if err := RootCmd.Execute(); err != nil {
fmt.Println(err)
os.Exit(-1)
}
}
func init() {
RootCmd.PersistentFlags().Int("log-level", 1, "Set the log level of output. 0-Fatal 1-Info 2-Debug")
RootCmd.Flag("log-level").Shorthand = "l"
}
func instanceTokenFlags(cmd *cobra.Command) {
cmd.PersistentFlags().StringP(instanceToken.FlagConfigPath, "p", "/etc/vault", "Set config path to directory with tokens")
cmd.PersistentFlags().StringP(instanceToken.FlagInitRole, "r", "", "Set role of token to renew. (default *no role*)")
}
func newInstanceToken(cmd *cobra.Command) (*instanceToken.InstanceToken, error) {
var result *multierror.Error
log, err := LogLevel(cmd)
if err != nil {
return nil, err
}
v, err := vault.NewClient(nil)
if err != nil {
return nil, err
}
i := instanceToken.New(v, log)
initRole, err := cmd.Flags().GetString(instanceToken.FlagInitRole)
if err != nil {
result = multierror.Append(result, fmt.Errorf("error parsing %s '%s': %v", instanceToken.FlagInitRole, initRole, err))
}
if initRole == "" {
//Read env variable
initRole = os.Getenv("VAULT_INIT_ROLE")
if initRole == "" {
result = multierror.Append(result, fmt.Errorf("no token role was given. token role is required for this command: --%s", instanceToken.FlagInitRole))
}
}
i.SetInitRole(initRole)
vaultConfigPath, err := cmd.Flags().GetString(instanceToken.FlagConfigPath)
if err != nil {
result = multierror.Append(result, fmt.Errorf("error parsing %s '%s': %v", instanceToken.FlagConfigPath, vaultConfigPath, err))
}
if vaultConfigPath != "" {
abs, err := filepath.Abs(vaultConfigPath)
if err != nil {
result = multierror.Append(result, fmt.Errorf("error generating absoute path from path '%s': %v", vaultConfigPath, err))
}
i.SetVaultConfigPath(abs)
}
return i, result.ErrorOrNil()
}
func LogLevel(cmd *cobra.Command) (*logrus.Entry, error) {
logger := logrus.New()
i, err := RootCmd.PersistentFlags().GetInt("log-level")
if err != nil {
return nil, fmt.Errorf("failed to get log level of flag: %s", err)
}
if i < 0 || i > 2 {
return nil, fmt.Errorf("not a valid log level")
}
switch i {
case 0:
logger.Level = logrus.FatalLevel
case 1:
logger.Level = logrus.InfoLevel
case 2:
logger.Level = logrus.DebugLevel
}
return logrus.NewEntry(logger), nil
}
|
package mock
import chat "github.com/greatchat/gochat/transport"
// Client is a mock implementation chat Client
type Client struct {
ReceiveFunc func(src string) (chat.Message, error)
SendFunc func(dest string, msg chat.Message) error
ConsumerFunc func(src string) (chan chat.Message, error)
ProducerFunc func(dest string) (chan chat.Message, error)
}
// Receive is a mock implementation
func (mock *Client) Receive(src string) (chat.Message, error) {
return mock.ReceiveFunc(src)
}
// Send is a mock implementation
func (mock *Client) Send(dest string, msg chat.Message) error {
return mock.SendFunc(dest, msg)
}
// Consumer is a mock implementation
func (mock *Client) Consumer(src string) (chan chat.Message, error) {
return mock.ConsumerFunc(src)
}
// Producer is a mock implementation
func (mock *Client) Producer(dest string) (chan chat.Message, error) {
return mock.ProducerFunc(dest)
}
|
/**
* (C) Copyright IBM Corp. 2021.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package ibmcloudobjectstorages3apiv2_test
import (
"bytes"
"context"
"fmt"
"github.com/IBM/experimental-go-sdk/ibmcloudobjectstorages3apiv2"
"github.com/IBM/go-sdk-core/v5/core"
"github.com/go-openapi/strfmt"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"io"
"io/ioutil"
"net/http"
"net/http/httptest"
"os"
"time"
)
var _ = Describe(`IbmCloudObjectStorageS3ApiV2`, func() {
var testServer *httptest.Server
Describe(`Service constructor tests`, func() {
It(`Instantiate service client`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
})
It(`Instantiate service client with error: Invalid URL`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
It(`Instantiate service client with error: Invalid Auth`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://ibmcloudobjectstorages3apiv2/api",
Authenticator: &core.BasicAuthenticator{
Username: "",
Password: "",
},
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
})
Describe(`Service constructor tests using external config`, func() {
Context(`Using external config, construct service client instances`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "noauth",
}
It(`Create service client using external config successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url from constructor successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://testService/api",
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url programatically successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("https://testService/api")
Expect(err).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
})
Context(`Using external config, construct service client instances with error: Invalid Auth`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "someOtherAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
Context(`Using external config, construct service client instances with error: Invalid URL`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "NOAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
})
Describe(`Regional endpoint tests`, func() {
It(`GetServiceURLForRegion(region string)`, func() {
var url string
var err error
url, err = ibmcloudobjectstorages3apiv2.GetServiceURLForRegion("INVALID_REGION")
Expect(url).To(BeEmpty())
Expect(err).ToNot(BeNil())
fmt.Fprintf(GinkgoWriter, "Expected error: %s\n", err.Error())
})
})
Describe(`HeadBucket(headBucketOptions *HeadBucketOptions)`, func() {
headBucketPath := "/testString"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(headBucketPath))
Expect(req.Method).To(Equal("HEAD"))
res.WriteHeader(200)
}))
})
It(`Invoke HeadBucket successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.HeadBucket(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the HeadBucketOptions model
headBucketOptionsModel := new(ibmcloudobjectstorages3apiv2.HeadBucketOptions)
headBucketOptionsModel.Bucket = core.StringPtr("testString")
headBucketOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.HeadBucket(headBucketOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke HeadBucket with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the HeadBucketOptions model
headBucketOptionsModel := new(ibmcloudobjectstorages3apiv2.HeadBucketOptions)
headBucketOptionsModel.Bucket = core.StringPtr("testString")
headBucketOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.HeadBucket(headBucketOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the HeadBucketOptions model with no property values
headBucketOptionsModelNew := new(ibmcloudobjectstorages3apiv2.HeadBucketOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.HeadBucket(headBucketOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`HeadObject(headObjectOptions *HeadObjectOptions)`, func() {
headObjectPath := "/testString/testString"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(headObjectPath))
Expect(req.Method).To(Equal("HEAD"))
Expect(req.Header["If-Match"]).ToNot(BeNil())
Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Modified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Modified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["If-None-Match"]).ToNot(BeNil())
Expect(req.Header["If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Range"]).ToNot(BeNil())
Expect(req.Header["Range"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.URL.Query()["partNumber"]).To(Equal([]string{fmt.Sprint(int64(38))}))
res.WriteHeader(200)
}))
})
It(`Invoke HeadObject successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.HeadObject(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the HeadObjectOptions model
headObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.HeadObjectOptions)
headObjectOptionsModel.Bucket = core.StringPtr("testString")
headObjectOptionsModel.Key = core.StringPtr("testString")
headObjectOptionsModel.IfMatch = core.StringPtr("testString")
headObjectOptionsModel.IfModifiedSince = CreateMockDateTime()
headObjectOptionsModel.IfNoneMatch = core.StringPtr("testString")
headObjectOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
headObjectOptionsModel.Range = core.StringPtr("testString")
headObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
headObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
headObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
headObjectOptionsModel.PartNumber = core.Int64Ptr(int64(38))
headObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.HeadObject(headObjectOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke HeadObject with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the HeadObjectOptions model
headObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.HeadObjectOptions)
headObjectOptionsModel.Bucket = core.StringPtr("testString")
headObjectOptionsModel.Key = core.StringPtr("testString")
headObjectOptionsModel.IfMatch = core.StringPtr("testString")
headObjectOptionsModel.IfModifiedSince = CreateMockDateTime()
headObjectOptionsModel.IfNoneMatch = core.StringPtr("testString")
headObjectOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
headObjectOptionsModel.Range = core.StringPtr("testString")
headObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
headObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
headObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
headObjectOptionsModel.PartNumber = core.Int64Ptr(int64(38))
headObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.HeadObject(headObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the HeadObjectOptions model with no property values
headObjectOptionsModelNew := new(ibmcloudobjectstorages3apiv2.HeadObjectOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.HeadObject(headObjectOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`ListBuckets(listBucketsOptions *ListBucketsOptions) - Operation response error`, func() {
listBucketsPath := "/"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listBucketsPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.Header["Ibm-Service-Instance-Id"]).ToNot(BeNil())
Expect(req.Header["Ibm-Service-Instance-Id"][0]).To(Equal(fmt.Sprintf("%v", "d6f76k03-6k4f-4a82-n165-697654o63903")))
// TODO: Add check for extended query parameter
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke ListBuckets with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the ListBucketsOptions model
listBucketsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListBucketsOptions)
listBucketsOptionsModel.IbmServiceInstanceID = core.StringPtr("d6f76k03-6k4f-4a82-n165-697654o63903")
listBucketsOptionsModel.Extended = core.BoolPtr(true)
listBucketsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListBuckets(listBucketsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListBuckets(listBucketsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`ListBuckets(listBucketsOptions *ListBucketsOptions)`, func() {
listBucketsPath := "/"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listBucketsPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.Header["Ibm-Service-Instance-Id"]).ToNot(BeNil())
Expect(req.Header["Ibm-Service-Instance-Id"][0]).To(Equal(fmt.Sprintf("%v", "d6f76k03-6k4f-4a82-n165-697654o63903")))
// TODO: Add check for extended query parameter
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"owner": {"id": "d6f76k03-6k4f-4a82-n165-697654o63903", "displayName": "d6f76k03-6k4f-4a82-n165-697654o63903"}, "buckets": [{"name": "myBucket", "creationDate": "2019-04-29T20:49:22.374Z"}]}`)
}))
})
It(`Invoke ListBuckets successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the ListBucketsOptions model
listBucketsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListBucketsOptions)
listBucketsOptionsModel.IbmServiceInstanceID = core.StringPtr("d6f76k03-6k4f-4a82-n165-697654o63903")
listBucketsOptionsModel.Extended = core.BoolPtr(true)
listBucketsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.ListBucketsWithContext(ctx, listBucketsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListBuckets(listBucketsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.ListBucketsWithContext(ctx, listBucketsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listBucketsPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.Header["Ibm-Service-Instance-Id"]).ToNot(BeNil())
Expect(req.Header["Ibm-Service-Instance-Id"][0]).To(Equal(fmt.Sprintf("%v", "d6f76k03-6k4f-4a82-n165-697654o63903")))
// TODO: Add check for extended query parameter
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"owner": {"id": "d6f76k03-6k4f-4a82-n165-697654o63903", "displayName": "d6f76k03-6k4f-4a82-n165-697654o63903"}, "buckets": [{"name": "myBucket", "creationDate": "2019-04-29T20:49:22.374Z"}]}`)
}))
})
It(`Invoke ListBuckets successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListBuckets(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the ListBucketsOptions model
listBucketsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListBucketsOptions)
listBucketsOptionsModel.IbmServiceInstanceID = core.StringPtr("d6f76k03-6k4f-4a82-n165-697654o63903")
listBucketsOptionsModel.Extended = core.BoolPtr(true)
listBucketsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListBuckets(listBucketsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke ListBuckets with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the ListBucketsOptions model
listBucketsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListBucketsOptions)
listBucketsOptionsModel.IbmServiceInstanceID = core.StringPtr("d6f76k03-6k4f-4a82-n165-697654o63903")
listBucketsOptionsModel.Extended = core.BoolPtr(true)
listBucketsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListBuckets(listBucketsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the ListBucketsOptions model with no property values
listBucketsOptionsModelNew := new(ibmcloudobjectstorages3apiv2.ListBucketsOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListBuckets(listBucketsOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`CreateBucket(createBucketOptions *CreateBucketOptions)`, func() {
createBucketPath := "/my-new-bucket"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(createBucketPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["Ibm-Service-Instance-Id"]).ToNot(BeNil())
Expect(req.Header["Ibm-Service-Instance-Id"][0]).To(Equal(fmt.Sprintf("%v", "d6f76k03-6k4f-4a82-n165-697654o63903")))
Expect(req.Header["Ibm-Sse-Kp-Encryption-Algorithm"]).ToNot(BeNil())
Expect(req.Header["Ibm-Sse-Kp-Encryption-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "AES256")))
Expect(req.Header["Ibm-Sse-Kp-Customer-Root-Key-Crn"]).ToNot(BeNil())
Expect(req.Header["Ibm-Sse-Kp-Customer-Root-Key-Crn"][0]).To(Equal(fmt.Sprintf("%v", "crn:v1:bluemix:public:kms:us-south:a/f047b55a3362ac06afad8a3f2f5586ea:12e8c9c2-a162-472d-b7d6-8b9a86b815a6:key:02fd6835-6001-4482-a892-13bd2085f75d")))
Expect(req.Header["X-Amz-Acl"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Acl"][0]).To(Equal(fmt.Sprintf("%v", "private")))
res.WriteHeader(200)
}))
})
It(`Invoke CreateBucket successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.CreateBucket(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the CreateBucketOptions model
createBucketOptionsModel := new(ibmcloudobjectstorages3apiv2.CreateBucketOptions)
createBucketOptionsModel.Bucket = core.StringPtr("my-new-bucket")
createBucketOptionsModel.IbmServiceInstanceID = core.StringPtr("d6f76k03-6k4f-4a82-n165-697654o63903")
createBucketOptionsModel.Body = core.StringPtr("testString")
createBucketOptionsModel.IbmSseKpEncryptionAlgorithm = core.StringPtr("AES256")
createBucketOptionsModel.IbmSseKpCustomerRootKeyCrn = core.StringPtr("crn:v1:bluemix:public:kms:us-south:a/f047b55a3362ac06afad8a3f2f5586ea:12e8c9c2-a162-472d-b7d6-8b9a86b815a6:key:02fd6835-6001-4482-a892-13bd2085f75d")
createBucketOptionsModel.XAmzAcl = core.StringPtr("private")
createBucketOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.CreateBucket(createBucketOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke CreateBucket with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the CreateBucketOptions model
createBucketOptionsModel := new(ibmcloudobjectstorages3apiv2.CreateBucketOptions)
createBucketOptionsModel.Bucket = core.StringPtr("my-new-bucket")
createBucketOptionsModel.IbmServiceInstanceID = core.StringPtr("d6f76k03-6k4f-4a82-n165-697654o63903")
createBucketOptionsModel.Body = core.StringPtr("testString")
createBucketOptionsModel.IbmSseKpEncryptionAlgorithm = core.StringPtr("AES256")
createBucketOptionsModel.IbmSseKpCustomerRootKeyCrn = core.StringPtr("crn:v1:bluemix:public:kms:us-south:a/f047b55a3362ac06afad8a3f2f5586ea:12e8c9c2-a162-472d-b7d6-8b9a86b815a6:key:02fd6835-6001-4482-a892-13bd2085f75d")
createBucketOptionsModel.XAmzAcl = core.StringPtr("private")
createBucketOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.CreateBucket(createBucketOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the CreateBucketOptions model with no property values
createBucketOptionsModelNew := new(ibmcloudobjectstorages3apiv2.CreateBucketOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.CreateBucket(createBucketOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`DeleteBucket(deleteBucketOptions *DeleteBucketOptions)`, func() {
deleteBucketPath := "/testString"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(deleteBucketPath))
Expect(req.Method).To(Equal("DELETE"))
res.WriteHeader(204)
}))
})
It(`Invoke DeleteBucket successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteBucket(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the DeleteBucketOptions model
deleteBucketOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteBucketOptions)
deleteBucketOptionsModel.Bucket = core.StringPtr("testString")
deleteBucketOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteBucket(deleteBucketOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke DeleteBucket with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the DeleteBucketOptions model
deleteBucketOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteBucketOptions)
deleteBucketOptionsModel.Bucket = core.StringPtr("testString")
deleteBucketOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteBucket(deleteBucketOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the DeleteBucketOptions model with no property values
deleteBucketOptionsModelNew := new(ibmcloudobjectstorages3apiv2.DeleteBucketOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteBucket(deleteBucketOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`ListObjects(listObjectsOptions *ListObjectsOptions) - Operation response error`, func() {
listObjectsPath := "/testString"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listObjectsPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.URL.Query()["delimiter"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["encoding-type"]).To(Equal([]string{"url"}))
Expect(req.URL.Query()["marker"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["max-keys"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["prefix"]).To(Equal([]string{"testString"}))
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke ListObjects with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the ListObjectsOptions model
listObjectsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListObjectsOptions)
listObjectsOptionsModel.Bucket = core.StringPtr("testString")
listObjectsOptionsModel.Delimiter = core.StringPtr("testString")
listObjectsOptionsModel.EncodingType = core.StringPtr("url")
listObjectsOptionsModel.Marker = core.StringPtr("testString")
listObjectsOptionsModel.MaxKeys = core.Int64Ptr(int64(38))
listObjectsOptionsModel.Prefix = core.StringPtr("testString")
listObjectsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListObjects(listObjectsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListObjects(listObjectsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`ListObjects(listObjectsOptions *ListObjectsOptions)`, func() {
listObjectsPath := "/testString"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listObjectsPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.URL.Query()["delimiter"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["encoding-type"]).To(Equal([]string{"url"}))
Expect(req.URL.Query()["marker"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["max-keys"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["prefix"]).To(Equal([]string{"testString"}))
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"IsTruncated": false, "Marker": "Marker", "NextMarker": "NextMarker", "Contents": {}, "Name": "Name", "Prefix": "Prefix", "Delimiter": "Delimiter", "MaxKeys": 7, "CommonPrefixes": {}, "EncodingType": "url"}`)
}))
})
It(`Invoke ListObjects successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the ListObjectsOptions model
listObjectsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListObjectsOptions)
listObjectsOptionsModel.Bucket = core.StringPtr("testString")
listObjectsOptionsModel.Delimiter = core.StringPtr("testString")
listObjectsOptionsModel.EncodingType = core.StringPtr("url")
listObjectsOptionsModel.Marker = core.StringPtr("testString")
listObjectsOptionsModel.MaxKeys = core.Int64Ptr(int64(38))
listObjectsOptionsModel.Prefix = core.StringPtr("testString")
listObjectsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.ListObjectsWithContext(ctx, listObjectsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListObjects(listObjectsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.ListObjectsWithContext(ctx, listObjectsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listObjectsPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.URL.Query()["delimiter"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["encoding-type"]).To(Equal([]string{"url"}))
Expect(req.URL.Query()["marker"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["max-keys"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["prefix"]).To(Equal([]string{"testString"}))
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"IsTruncated": false, "Marker": "Marker", "NextMarker": "NextMarker", "Contents": {}, "Name": "Name", "Prefix": "Prefix", "Delimiter": "Delimiter", "MaxKeys": 7, "CommonPrefixes": {}, "EncodingType": "url"}`)
}))
})
It(`Invoke ListObjects successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListObjects(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the ListObjectsOptions model
listObjectsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListObjectsOptions)
listObjectsOptionsModel.Bucket = core.StringPtr("testString")
listObjectsOptionsModel.Delimiter = core.StringPtr("testString")
listObjectsOptionsModel.EncodingType = core.StringPtr("url")
listObjectsOptionsModel.Marker = core.StringPtr("testString")
listObjectsOptionsModel.MaxKeys = core.Int64Ptr(int64(38))
listObjectsOptionsModel.Prefix = core.StringPtr("testString")
listObjectsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListObjects(listObjectsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke ListObjects with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the ListObjectsOptions model
listObjectsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListObjectsOptions)
listObjectsOptionsModel.Bucket = core.StringPtr("testString")
listObjectsOptionsModel.Delimiter = core.StringPtr("testString")
listObjectsOptionsModel.EncodingType = core.StringPtr("url")
listObjectsOptionsModel.Marker = core.StringPtr("testString")
listObjectsOptionsModel.MaxKeys = core.Int64Ptr(int64(38))
listObjectsOptionsModel.Prefix = core.StringPtr("testString")
listObjectsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListObjects(listObjectsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the ListObjectsOptions model with no property values
listObjectsOptionsModelNew := new(ibmcloudobjectstorages3apiv2.ListObjectsOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListObjects(listObjectsOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`ListObjectsV2(listObjectsV2Options *ListObjectsV2Options) - Operation response error`, func() {
listObjectsV2Path := "/testString?list-type=2"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listObjectsV2Path))
Expect(req.Method).To(Equal("GET"))
Expect(req.URL.Query()["list-type"]).To(Equal([]string{"2"}))
Expect(req.URL.Query()["delimiter"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["encoding-type"]).To(Equal([]string{"url"}))
Expect(req.URL.Query()["max-keys"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["prefix"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["continuation-token"]).To(Equal([]string{"testString"}))
// TODO: Add check for fetch-owner query parameter
Expect(req.URL.Query()["start-after"]).To(Equal([]string{"testString"}))
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke ListObjectsV2 with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the ListObjectsV2Options model
listObjectsV2OptionsModel := new(ibmcloudobjectstorages3apiv2.ListObjectsV2Options)
listObjectsV2OptionsModel.Bucket = core.StringPtr("testString")
listObjectsV2OptionsModel.ListType = core.StringPtr("2")
listObjectsV2OptionsModel.Delimiter = core.StringPtr("testString")
listObjectsV2OptionsModel.EncodingType = core.StringPtr("url")
listObjectsV2OptionsModel.MaxKeys = core.Int64Ptr(int64(38))
listObjectsV2OptionsModel.Prefix = core.StringPtr("testString")
listObjectsV2OptionsModel.ContinuationToken = core.StringPtr("testString")
listObjectsV2OptionsModel.FetchOwner = core.BoolPtr(true)
listObjectsV2OptionsModel.StartAfter = core.StringPtr("testString")
listObjectsV2OptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListObjectsV2(listObjectsV2OptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListObjectsV2(listObjectsV2OptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`ListObjectsV2(listObjectsV2Options *ListObjectsV2Options)`, func() {
listObjectsV2Path := "/testString?list-type=2"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listObjectsV2Path))
Expect(req.Method).To(Equal("GET"))
Expect(req.URL.Query()["list-type"]).To(Equal([]string{"2"}))
Expect(req.URL.Query()["delimiter"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["encoding-type"]).To(Equal([]string{"url"}))
Expect(req.URL.Query()["max-keys"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["prefix"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["continuation-token"]).To(Equal([]string{"testString"}))
// TODO: Add check for fetch-owner query parameter
Expect(req.URL.Query()["start-after"]).To(Equal([]string{"testString"}))
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"IsTruncated": false, "Contents": {}, "Name": "Name", "Prefix": "Prefix", "Delimiter": "Delimiter", "MaxKeys": 7, "CommonPrefixes": {}, "EncodingType": "url", "KeyCount": 8, "ContinuationToken": "ContinuationToken", "NextContinuationToken": "NextContinuationToken", "StartAfter": "StartAfter"}`)
}))
})
It(`Invoke ListObjectsV2 successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the ListObjectsV2Options model
listObjectsV2OptionsModel := new(ibmcloudobjectstorages3apiv2.ListObjectsV2Options)
listObjectsV2OptionsModel.Bucket = core.StringPtr("testString")
listObjectsV2OptionsModel.ListType = core.StringPtr("2")
listObjectsV2OptionsModel.Delimiter = core.StringPtr("testString")
listObjectsV2OptionsModel.EncodingType = core.StringPtr("url")
listObjectsV2OptionsModel.MaxKeys = core.Int64Ptr(int64(38))
listObjectsV2OptionsModel.Prefix = core.StringPtr("testString")
listObjectsV2OptionsModel.ContinuationToken = core.StringPtr("testString")
listObjectsV2OptionsModel.FetchOwner = core.BoolPtr(true)
listObjectsV2OptionsModel.StartAfter = core.StringPtr("testString")
listObjectsV2OptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.ListObjectsV2WithContext(ctx, listObjectsV2OptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListObjectsV2(listObjectsV2OptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.ListObjectsV2WithContext(ctx, listObjectsV2OptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listObjectsV2Path))
Expect(req.Method).To(Equal("GET"))
Expect(req.URL.Query()["list-type"]).To(Equal([]string{"2"}))
Expect(req.URL.Query()["delimiter"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["encoding-type"]).To(Equal([]string{"url"}))
Expect(req.URL.Query()["max-keys"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["prefix"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["continuation-token"]).To(Equal([]string{"testString"}))
// TODO: Add check for fetch-owner query parameter
Expect(req.URL.Query()["start-after"]).To(Equal([]string{"testString"}))
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"IsTruncated": false, "Contents": {}, "Name": "Name", "Prefix": "Prefix", "Delimiter": "Delimiter", "MaxKeys": 7, "CommonPrefixes": {}, "EncodingType": "url", "KeyCount": 8, "ContinuationToken": "ContinuationToken", "NextContinuationToken": "NextContinuationToken", "StartAfter": "StartAfter"}`)
}))
})
It(`Invoke ListObjectsV2 successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListObjectsV2(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the ListObjectsV2Options model
listObjectsV2OptionsModel := new(ibmcloudobjectstorages3apiv2.ListObjectsV2Options)
listObjectsV2OptionsModel.Bucket = core.StringPtr("testString")
listObjectsV2OptionsModel.ListType = core.StringPtr("2")
listObjectsV2OptionsModel.Delimiter = core.StringPtr("testString")
listObjectsV2OptionsModel.EncodingType = core.StringPtr("url")
listObjectsV2OptionsModel.MaxKeys = core.Int64Ptr(int64(38))
listObjectsV2OptionsModel.Prefix = core.StringPtr("testString")
listObjectsV2OptionsModel.ContinuationToken = core.StringPtr("testString")
listObjectsV2OptionsModel.FetchOwner = core.BoolPtr(true)
listObjectsV2OptionsModel.StartAfter = core.StringPtr("testString")
listObjectsV2OptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListObjectsV2(listObjectsV2OptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke ListObjectsV2 with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the ListObjectsV2Options model
listObjectsV2OptionsModel := new(ibmcloudobjectstorages3apiv2.ListObjectsV2Options)
listObjectsV2OptionsModel.Bucket = core.StringPtr("testString")
listObjectsV2OptionsModel.ListType = core.StringPtr("2")
listObjectsV2OptionsModel.Delimiter = core.StringPtr("testString")
listObjectsV2OptionsModel.EncodingType = core.StringPtr("url")
listObjectsV2OptionsModel.MaxKeys = core.Int64Ptr(int64(38))
listObjectsV2OptionsModel.Prefix = core.StringPtr("testString")
listObjectsV2OptionsModel.ContinuationToken = core.StringPtr("testString")
listObjectsV2OptionsModel.FetchOwner = core.BoolPtr(true)
listObjectsV2OptionsModel.StartAfter = core.StringPtr("testString")
listObjectsV2OptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListObjectsV2(listObjectsV2OptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the ListObjectsV2Options model with no property values
listObjectsV2OptionsModelNew := new(ibmcloudobjectstorages3apiv2.ListObjectsV2Options)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListObjectsV2(listObjectsV2OptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`PutObject(putObjectOptions *PutObjectOptions)`, func() {
putObjectPath := "/testString/testString"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(putObjectPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["X-Amz-Acl"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Acl"][0]).To(Equal(fmt.Sprintf("%v", "private")))
Expect(req.Header["If-Match"]).ToNot(BeNil())
Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-None-Match"]).ToNot(BeNil())
Expect(req.Header["If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Cache-Control"]).ToNot(BeNil())
Expect(req.Header["Cache-Control"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Disposition"]).ToNot(BeNil())
Expect(req.Header["Content-Disposition"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Encoding"]).ToNot(BeNil())
Expect(req.Header["Content-Encoding"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Language"]).ToNot(BeNil())
Expect(req.Header["Content-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Length"]).ToNot(BeNil())
Expect(req.Header["Content-Length"][0]).To(Equal(fmt.Sprintf("%v", int64(38))))
Expect(req.Header["Content-Md5"]).ToNot(BeNil())
Expect(req.Header["Content-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Expires"]).ToNot(BeNil())
Expect(req.Header["Expires"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Server-Side-Encryption"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption"][0]).To(Equal(fmt.Sprintf("%v", "AES256")))
Expect(req.Header["X-Amz-Website-Redirect-Location"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Website-Redirect-Location"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Tagging"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Tagging"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
res.WriteHeader(200)
}))
})
It(`Invoke PutObject successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.PutObject(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the PutObjectOptions model
putObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.PutObjectOptions)
putObjectOptionsModel.Bucket = core.StringPtr("testString")
putObjectOptionsModel.Key = core.StringPtr("testString")
putObjectOptionsModel.Body = core.StringPtr("testString")
putObjectOptionsModel.XAmzAcl = core.StringPtr("private")
putObjectOptionsModel.IfMatch = core.StringPtr("testString")
putObjectOptionsModel.IfNoneMatch = core.StringPtr("testString")
putObjectOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
putObjectOptionsModel.CacheControl = core.StringPtr("testString")
putObjectOptionsModel.ContentDisposition = core.StringPtr("testString")
putObjectOptionsModel.ContentEncoding = core.StringPtr("testString")
putObjectOptionsModel.ContentLanguage = core.StringPtr("testString")
putObjectOptionsModel.ContentLength = core.Int64Ptr(int64(38))
putObjectOptionsModel.ContentMD5 = core.StringPtr("testString")
putObjectOptionsModel.Expires = CreateMockDateTime()
putObjectOptionsModel.XAmzServerSideEncryption = core.StringPtr("AES256")
putObjectOptionsModel.XAmzWebsiteRedirectLocation = core.StringPtr("testString")
putObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
putObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
putObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
putObjectOptionsModel.XAmzTagging = core.StringPtr("testString")
putObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutObject(putObjectOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke PutObject with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the PutObjectOptions model
putObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.PutObjectOptions)
putObjectOptionsModel.Bucket = core.StringPtr("testString")
putObjectOptionsModel.Key = core.StringPtr("testString")
putObjectOptionsModel.Body = core.StringPtr("testString")
putObjectOptionsModel.XAmzAcl = core.StringPtr("private")
putObjectOptionsModel.IfMatch = core.StringPtr("testString")
putObjectOptionsModel.IfNoneMatch = core.StringPtr("testString")
putObjectOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
putObjectOptionsModel.CacheControl = core.StringPtr("testString")
putObjectOptionsModel.ContentDisposition = core.StringPtr("testString")
putObjectOptionsModel.ContentEncoding = core.StringPtr("testString")
putObjectOptionsModel.ContentLanguage = core.StringPtr("testString")
putObjectOptionsModel.ContentLength = core.Int64Ptr(int64(38))
putObjectOptionsModel.ContentMD5 = core.StringPtr("testString")
putObjectOptionsModel.Expires = CreateMockDateTime()
putObjectOptionsModel.XAmzServerSideEncryption = core.StringPtr("AES256")
putObjectOptionsModel.XAmzWebsiteRedirectLocation = core.StringPtr("testString")
putObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
putObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
putObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
putObjectOptionsModel.XAmzTagging = core.StringPtr("testString")
putObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.PutObject(putObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the PutObjectOptions model with no property values
putObjectOptionsModelNew := new(ibmcloudobjectstorages3apiv2.PutObjectOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutObject(putObjectOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetObject(getObjectOptions *GetObjectOptions) - Operation response error`, func() {
getObjectPath := "/testString/testString"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getObjectPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.Header["If-Match"]).ToNot(BeNil())
Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Modified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Modified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["If-None-Match"]).ToNot(BeNil())
Expect(req.Header["If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Range"]).ToNot(BeNil())
Expect(req.Header["Range"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.URL.Query()["response-cache-control"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-disposition"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-encoding"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-language"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-type"]).To(Equal([]string{"testString"}))
// TODO: Add check for response-expires query parameter
Expect(req.URL.Query()["partNumber"]).To(Equal([]string{fmt.Sprint(int64(38))}))
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke GetObject with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetObjectOptions model
getObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectOptions)
getObjectOptionsModel.Bucket = core.StringPtr("testString")
getObjectOptionsModel.Key = core.StringPtr("testString")
getObjectOptionsModel.IfMatch = core.StringPtr("testString")
getObjectOptionsModel.IfModifiedSince = CreateMockDateTime()
getObjectOptionsModel.IfNoneMatch = core.StringPtr("testString")
getObjectOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
getObjectOptionsModel.Range = core.StringPtr("testString")
getObjectOptionsModel.ResponseCacheControl = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentDisposition = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentEncoding = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentLanguage = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentType = core.StringPtr("testString")
getObjectOptionsModel.ResponseExpires = CreateMockDateTime()
getObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
getObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
getObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
getObjectOptionsModel.PartNumber = core.Int64Ptr(int64(38))
getObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObject(getObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetObject(getObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetObject(getObjectOptions *GetObjectOptions)`, func() {
getObjectPath := "/testString/testString"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getObjectPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.Header["If-Match"]).ToNot(BeNil())
Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Modified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Modified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["If-None-Match"]).ToNot(BeNil())
Expect(req.Header["If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Range"]).ToNot(BeNil())
Expect(req.Header["Range"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.URL.Query()["response-cache-control"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-disposition"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-encoding"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-language"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-type"]).To(Equal([]string{"testString"}))
// TODO: Add check for response-expires query parameter
Expect(req.URL.Query()["partNumber"]).To(Equal([]string{fmt.Sprint(int64(38))}))
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Body": "Body", "Metadata": {}}`)
}))
})
It(`Invoke GetObject successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the GetObjectOptions model
getObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectOptions)
getObjectOptionsModel.Bucket = core.StringPtr("testString")
getObjectOptionsModel.Key = core.StringPtr("testString")
getObjectOptionsModel.IfMatch = core.StringPtr("testString")
getObjectOptionsModel.IfModifiedSince = CreateMockDateTime()
getObjectOptionsModel.IfNoneMatch = core.StringPtr("testString")
getObjectOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
getObjectOptionsModel.Range = core.StringPtr("testString")
getObjectOptionsModel.ResponseCacheControl = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentDisposition = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentEncoding = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentLanguage = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentType = core.StringPtr("testString")
getObjectOptionsModel.ResponseExpires = CreateMockDateTime()
getObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
getObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
getObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
getObjectOptionsModel.PartNumber = core.Int64Ptr(int64(38))
getObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectWithContext(ctx, getObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObject(getObjectOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.GetObjectWithContext(ctx, getObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getObjectPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.Header["If-Match"]).ToNot(BeNil())
Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Modified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Modified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["If-None-Match"]).ToNot(BeNil())
Expect(req.Header["If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Range"]).ToNot(BeNil())
Expect(req.Header["Range"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.URL.Query()["response-cache-control"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-disposition"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-encoding"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-language"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["response-content-type"]).To(Equal([]string{"testString"}))
// TODO: Add check for response-expires query parameter
Expect(req.URL.Query()["partNumber"]).To(Equal([]string{fmt.Sprint(int64(38))}))
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Body": "Body", "Metadata": {}}`)
}))
})
It(`Invoke GetObject successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObject(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the GetObjectOptions model
getObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectOptions)
getObjectOptionsModel.Bucket = core.StringPtr("testString")
getObjectOptionsModel.Key = core.StringPtr("testString")
getObjectOptionsModel.IfMatch = core.StringPtr("testString")
getObjectOptionsModel.IfModifiedSince = CreateMockDateTime()
getObjectOptionsModel.IfNoneMatch = core.StringPtr("testString")
getObjectOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
getObjectOptionsModel.Range = core.StringPtr("testString")
getObjectOptionsModel.ResponseCacheControl = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentDisposition = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentEncoding = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentLanguage = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentType = core.StringPtr("testString")
getObjectOptionsModel.ResponseExpires = CreateMockDateTime()
getObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
getObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
getObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
getObjectOptionsModel.PartNumber = core.Int64Ptr(int64(38))
getObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetObject(getObjectOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke GetObject with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetObjectOptions model
getObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectOptions)
getObjectOptionsModel.Bucket = core.StringPtr("testString")
getObjectOptionsModel.Key = core.StringPtr("testString")
getObjectOptionsModel.IfMatch = core.StringPtr("testString")
getObjectOptionsModel.IfModifiedSince = CreateMockDateTime()
getObjectOptionsModel.IfNoneMatch = core.StringPtr("testString")
getObjectOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
getObjectOptionsModel.Range = core.StringPtr("testString")
getObjectOptionsModel.ResponseCacheControl = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentDisposition = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentEncoding = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentLanguage = core.StringPtr("testString")
getObjectOptionsModel.ResponseContentType = core.StringPtr("testString")
getObjectOptionsModel.ResponseExpires = CreateMockDateTime()
getObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
getObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
getObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
getObjectOptionsModel.PartNumber = core.Int64Ptr(int64(38))
getObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObject(getObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the GetObjectOptions model with no property values
getObjectOptionsModelNew := new(ibmcloudobjectstorages3apiv2.GetObjectOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetObject(getObjectOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`DeleteObject(deleteObjectOptions *DeleteObjectOptions)`, func() {
deleteObjectPath := "/testString/testString"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(deleteObjectPath))
Expect(req.Method).To(Equal("DELETE"))
res.WriteHeader(204)
}))
})
It(`Invoke DeleteObject successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteObject(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the DeleteObjectOptions model
deleteObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteObjectOptions)
deleteObjectOptionsModel.Bucket = core.StringPtr("testString")
deleteObjectOptionsModel.Key = core.StringPtr("testString")
deleteObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteObject(deleteObjectOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke DeleteObject with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the DeleteObjectOptions model
deleteObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteObjectOptions)
deleteObjectOptionsModel.Bucket = core.StringPtr("testString")
deleteObjectOptionsModel.Key = core.StringPtr("testString")
deleteObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteObject(deleteObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the DeleteObjectOptions model with no property values
deleteObjectOptionsModelNew := new(ibmcloudobjectstorages3apiv2.DeleteObjectOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteObject(deleteObjectOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`CopyObject(copyObjectOptions *CopyObjectOptions) - Operation response error`, func() {
copyObjectPath := "/testString/testString"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(copyObjectPath))
Expect(req.Method).To(Equal("PUT"))
Expect(req.Header["X-Amz-Copy-Source"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Acl"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Acl"][0]).To(Equal(fmt.Sprintf("%v", "private")))
Expect(req.Header["Cache-Control"]).ToNot(BeNil())
Expect(req.Header["Cache-Control"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Disposition"]).ToNot(BeNil())
Expect(req.Header["Content-Disposition"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Encoding"]).ToNot(BeNil())
Expect(req.Header["Content-Encoding"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Language"]).ToNot(BeNil())
Expect(req.Header["Content-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Expires"]).ToNot(BeNil())
Expect(req.Header["Expires"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Metadata-Directive"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Metadata-Directive"][0]).To(Equal(fmt.Sprintf("%v", "COPY")))
Expect(req.Header["X-Amz-Tagging-Directive"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Tagging-Directive"][0]).To(Equal(fmt.Sprintf("%v", "COPY")))
Expect(req.Header["X-Amz-Server-Side-Encryption"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption"][0]).To(Equal(fmt.Sprintf("%v", "AES256")))
Expect(req.Header["X-Amz-Website-Redirect-Location"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Website-Redirect-Location"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Tagging"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Tagging"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke CopyObject with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the CopyObjectOptions model
copyObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.CopyObjectOptions)
copyObjectOptionsModel.Bucket = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySource = core.StringPtr("testString")
copyObjectOptionsModel.TargetKey = core.StringPtr("testString")
copyObjectOptionsModel.Body = core.StringPtr("testString")
copyObjectOptionsModel.XAmzAcl = core.StringPtr("private")
copyObjectOptionsModel.CacheControl = core.StringPtr("testString")
copyObjectOptionsModel.ContentDisposition = core.StringPtr("testString")
copyObjectOptionsModel.ContentEncoding = core.StringPtr("testString")
copyObjectOptionsModel.ContentLanguage = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfMatch = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfModifiedSince = CreateMockDateTime()
copyObjectOptionsModel.XAmzCopySourceIfNoneMatch = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfUnmodifiedSince = CreateMockDateTime()
copyObjectOptionsModel.Expires = CreateMockDateTime()
copyObjectOptionsModel.XAmzMetadataDirective = core.StringPtr("COPY")
copyObjectOptionsModel.XAmzTaggingDirective = core.StringPtr("COPY")
copyObjectOptionsModel.XAmzServerSideEncryption = core.StringPtr("AES256")
copyObjectOptionsModel.XAmzWebsiteRedirectLocation = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKey = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
copyObjectOptionsModel.XAmzTagging = core.StringPtr("testString")
copyObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.CopyObject(copyObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.CopyObject(copyObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`CopyObject(copyObjectOptions *CopyObjectOptions)`, func() {
copyObjectPath := "/testString/testString"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(copyObjectPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["X-Amz-Copy-Source"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Acl"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Acl"][0]).To(Equal(fmt.Sprintf("%v", "private")))
Expect(req.Header["Cache-Control"]).ToNot(BeNil())
Expect(req.Header["Cache-Control"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Disposition"]).ToNot(BeNil())
Expect(req.Header["Content-Disposition"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Encoding"]).ToNot(BeNil())
Expect(req.Header["Content-Encoding"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Language"]).ToNot(BeNil())
Expect(req.Header["Content-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Expires"]).ToNot(BeNil())
Expect(req.Header["Expires"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Metadata-Directive"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Metadata-Directive"][0]).To(Equal(fmt.Sprintf("%v", "COPY")))
Expect(req.Header["X-Amz-Tagging-Directive"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Tagging-Directive"][0]).To(Equal(fmt.Sprintf("%v", "COPY")))
Expect(req.Header["X-Amz-Server-Side-Encryption"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption"][0]).To(Equal(fmt.Sprintf("%v", "AES256")))
Expect(req.Header["X-Amz-Website-Redirect-Location"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Website-Redirect-Location"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Tagging"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Tagging"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"CopyObjectResult": {"ETag": "ETag", "LastModified": "2019-01-01T12:00:00.000Z"}}`)
}))
})
It(`Invoke CopyObject successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the CopyObjectOptions model
copyObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.CopyObjectOptions)
copyObjectOptionsModel.Bucket = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySource = core.StringPtr("testString")
copyObjectOptionsModel.TargetKey = core.StringPtr("testString")
copyObjectOptionsModel.Body = core.StringPtr("testString")
copyObjectOptionsModel.XAmzAcl = core.StringPtr("private")
copyObjectOptionsModel.CacheControl = core.StringPtr("testString")
copyObjectOptionsModel.ContentDisposition = core.StringPtr("testString")
copyObjectOptionsModel.ContentEncoding = core.StringPtr("testString")
copyObjectOptionsModel.ContentLanguage = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfMatch = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfModifiedSince = CreateMockDateTime()
copyObjectOptionsModel.XAmzCopySourceIfNoneMatch = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfUnmodifiedSince = CreateMockDateTime()
copyObjectOptionsModel.Expires = CreateMockDateTime()
copyObjectOptionsModel.XAmzMetadataDirective = core.StringPtr("COPY")
copyObjectOptionsModel.XAmzTaggingDirective = core.StringPtr("COPY")
copyObjectOptionsModel.XAmzServerSideEncryption = core.StringPtr("AES256")
copyObjectOptionsModel.XAmzWebsiteRedirectLocation = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKey = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
copyObjectOptionsModel.XAmzTagging = core.StringPtr("testString")
copyObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.CopyObjectWithContext(ctx, copyObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.CopyObject(copyObjectOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.CopyObjectWithContext(ctx, copyObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(copyObjectPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["X-Amz-Copy-Source"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Acl"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Acl"][0]).To(Equal(fmt.Sprintf("%v", "private")))
Expect(req.Header["Cache-Control"]).ToNot(BeNil())
Expect(req.Header["Cache-Control"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Disposition"]).ToNot(BeNil())
Expect(req.Header["Content-Disposition"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Encoding"]).ToNot(BeNil())
Expect(req.Header["Content-Encoding"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Language"]).ToNot(BeNil())
Expect(req.Header["Content-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Expires"]).ToNot(BeNil())
Expect(req.Header["Expires"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Metadata-Directive"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Metadata-Directive"][0]).To(Equal(fmt.Sprintf("%v", "COPY")))
Expect(req.Header["X-Amz-Tagging-Directive"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Tagging-Directive"][0]).To(Equal(fmt.Sprintf("%v", "COPY")))
Expect(req.Header["X-Amz-Server-Side-Encryption"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption"][0]).To(Equal(fmt.Sprintf("%v", "AES256")))
Expect(req.Header["X-Amz-Website-Redirect-Location"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Website-Redirect-Location"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Tagging"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Tagging"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"CopyObjectResult": {"ETag": "ETag", "LastModified": "2019-01-01T12:00:00.000Z"}}`)
}))
})
It(`Invoke CopyObject successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.CopyObject(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the CopyObjectOptions model
copyObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.CopyObjectOptions)
copyObjectOptionsModel.Bucket = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySource = core.StringPtr("testString")
copyObjectOptionsModel.TargetKey = core.StringPtr("testString")
copyObjectOptionsModel.Body = core.StringPtr("testString")
copyObjectOptionsModel.XAmzAcl = core.StringPtr("private")
copyObjectOptionsModel.CacheControl = core.StringPtr("testString")
copyObjectOptionsModel.ContentDisposition = core.StringPtr("testString")
copyObjectOptionsModel.ContentEncoding = core.StringPtr("testString")
copyObjectOptionsModel.ContentLanguage = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfMatch = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfModifiedSince = CreateMockDateTime()
copyObjectOptionsModel.XAmzCopySourceIfNoneMatch = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfUnmodifiedSince = CreateMockDateTime()
copyObjectOptionsModel.Expires = CreateMockDateTime()
copyObjectOptionsModel.XAmzMetadataDirective = core.StringPtr("COPY")
copyObjectOptionsModel.XAmzTaggingDirective = core.StringPtr("COPY")
copyObjectOptionsModel.XAmzServerSideEncryption = core.StringPtr("AES256")
copyObjectOptionsModel.XAmzWebsiteRedirectLocation = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKey = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
copyObjectOptionsModel.XAmzTagging = core.StringPtr("testString")
copyObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.CopyObject(copyObjectOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke CopyObject with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the CopyObjectOptions model
copyObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.CopyObjectOptions)
copyObjectOptionsModel.Bucket = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySource = core.StringPtr("testString")
copyObjectOptionsModel.TargetKey = core.StringPtr("testString")
copyObjectOptionsModel.Body = core.StringPtr("testString")
copyObjectOptionsModel.XAmzAcl = core.StringPtr("private")
copyObjectOptionsModel.CacheControl = core.StringPtr("testString")
copyObjectOptionsModel.ContentDisposition = core.StringPtr("testString")
copyObjectOptionsModel.ContentEncoding = core.StringPtr("testString")
copyObjectOptionsModel.ContentLanguage = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfMatch = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfModifiedSince = CreateMockDateTime()
copyObjectOptionsModel.XAmzCopySourceIfNoneMatch = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceIfUnmodifiedSince = CreateMockDateTime()
copyObjectOptionsModel.Expires = CreateMockDateTime()
copyObjectOptionsModel.XAmzMetadataDirective = core.StringPtr("COPY")
copyObjectOptionsModel.XAmzTaggingDirective = core.StringPtr("COPY")
copyObjectOptionsModel.XAmzServerSideEncryption = core.StringPtr("AES256")
copyObjectOptionsModel.XAmzWebsiteRedirectLocation = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
copyObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKey = core.StringPtr("testString")
copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
copyObjectOptionsModel.XAmzTagging = core.StringPtr("testString")
copyObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.CopyObject(copyObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the CopyObjectOptions model with no property values
copyObjectOptionsModelNew := new(ibmcloudobjectstorages3apiv2.CopyObjectOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.CopyObject(copyObjectOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`DeleteObjects(deleteObjectsOptions *DeleteObjectsOptions) - Operation response error`, func() {
deleteObjectsPath := "/testString?delete"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(deleteObjectsPath))
Expect(req.Method).To(Equal("POST"))
// TODO: Add check for delete query parameter
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke DeleteObjects with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the DeleteObjectsOptions model
deleteObjectsOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteObjectsOptions)
deleteObjectsOptionsModel.Bucket = core.StringPtr("testString")
deleteObjectsOptionsModel.Delete = core.BoolPtr(true)
deleteObjectsOptionsModel.Body = core.StringPtr("testString")
deleteObjectsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteObjects(deleteObjectsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteObjects(deleteObjectsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`DeleteObjects(deleteObjectsOptions *DeleteObjectsOptions)`, func() {
deleteObjectsPath := "/testString?delete"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(deleteObjectsPath))
Expect(req.Method).To(Equal("POST"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
// TODO: Add check for delete query parameter
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Errors": {}}`)
}))
})
It(`Invoke DeleteObjects successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the DeleteObjectsOptions model
deleteObjectsOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteObjectsOptions)
deleteObjectsOptionsModel.Bucket = core.StringPtr("testString")
deleteObjectsOptionsModel.Delete = core.BoolPtr(true)
deleteObjectsOptionsModel.Body = core.StringPtr("testString")
deleteObjectsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.DeleteObjectsWithContext(ctx, deleteObjectsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteObjects(deleteObjectsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.DeleteObjectsWithContext(ctx, deleteObjectsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(deleteObjectsPath))
Expect(req.Method).To(Equal("POST"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
// TODO: Add check for delete query parameter
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Errors": {}}`)
}))
})
It(`Invoke DeleteObjects successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteObjects(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the DeleteObjectsOptions model
deleteObjectsOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteObjectsOptions)
deleteObjectsOptionsModel.Bucket = core.StringPtr("testString")
deleteObjectsOptionsModel.Delete = core.BoolPtr(true)
deleteObjectsOptionsModel.Body = core.StringPtr("testString")
deleteObjectsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteObjects(deleteObjectsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke DeleteObjects with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the DeleteObjectsOptions model
deleteObjectsOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteObjectsOptions)
deleteObjectsOptionsModel.Bucket = core.StringPtr("testString")
deleteObjectsOptionsModel.Delete = core.BoolPtr(true)
deleteObjectsOptionsModel.Body = core.StringPtr("testString")
deleteObjectsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteObjects(deleteObjectsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the DeleteObjectsOptions model with no property values
deleteObjectsOptionsModelNew := new(ibmcloudobjectstorages3apiv2.DeleteObjectsOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteObjects(deleteObjectsOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`Service constructor tests`, func() {
It(`Instantiate service client`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
})
It(`Instantiate service client with error: Invalid URL`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
It(`Instantiate service client with error: Invalid Auth`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://ibmcloudobjectstorages3apiv2/api",
Authenticator: &core.BasicAuthenticator{
Username: "",
Password: "",
},
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
})
Describe(`Service constructor tests using external config`, func() {
Context(`Using external config, construct service client instances`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "noauth",
}
It(`Create service client using external config successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url from constructor successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://testService/api",
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url programatically successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("https://testService/api")
Expect(err).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
})
Context(`Using external config, construct service client instances with error: Invalid Auth`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "someOtherAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
Context(`Using external config, construct service client instances with error: Invalid URL`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "NOAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
})
Describe(`Regional endpoint tests`, func() {
It(`GetServiceURLForRegion(region string)`, func() {
var url string
var err error
url, err = ibmcloudobjectstorages3apiv2.GetServiceURLForRegion("INVALID_REGION")
Expect(url).To(BeEmpty())
Expect(err).ToNot(BeNil())
fmt.Fprintf(GinkgoWriter, "Expected error: %s\n", err.Error())
})
})
Describe(`PutBucketProtectionConfiguration(putBucketProtectionConfigurationOptions *PutBucketProtectionConfigurationOptions)`, func() {
putBucketProtectionConfigurationPath := "/testString?protection"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(putBucketProtectionConfigurationPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
// TODO: Add check for protection query parameter
res.WriteHeader(200)
}))
})
It(`Invoke PutBucketProtectionConfiguration successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.PutBucketProtectionConfiguration(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the PutBucketProtectionConfigurationOptions model
putBucketProtectionConfigurationOptionsModel := new(ibmcloudobjectstorages3apiv2.PutBucketProtectionConfigurationOptions)
putBucketProtectionConfigurationOptionsModel.Bucket = core.StringPtr("testString")
putBucketProtectionConfigurationOptionsModel.Protection = core.BoolPtr(true)
putBucketProtectionConfigurationOptionsModel.Body = core.StringPtr("testString")
putBucketProtectionConfigurationOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutBucketProtectionConfiguration(putBucketProtectionConfigurationOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke PutBucketProtectionConfiguration with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the PutBucketProtectionConfigurationOptions model
putBucketProtectionConfigurationOptionsModel := new(ibmcloudobjectstorages3apiv2.PutBucketProtectionConfigurationOptions)
putBucketProtectionConfigurationOptionsModel.Bucket = core.StringPtr("testString")
putBucketProtectionConfigurationOptionsModel.Protection = core.BoolPtr(true)
putBucketProtectionConfigurationOptionsModel.Body = core.StringPtr("testString")
putBucketProtectionConfigurationOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.PutBucketProtectionConfiguration(putBucketProtectionConfigurationOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the PutBucketProtectionConfigurationOptions model with no property values
putBucketProtectionConfigurationOptionsModelNew := new(ibmcloudobjectstorages3apiv2.PutBucketProtectionConfigurationOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutBucketProtectionConfiguration(putBucketProtectionConfigurationOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`Service constructor tests`, func() {
It(`Instantiate service client`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
})
It(`Instantiate service client with error: Invalid URL`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
It(`Instantiate service client with error: Invalid Auth`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://ibmcloudobjectstorages3apiv2/api",
Authenticator: &core.BasicAuthenticator{
Username: "",
Password: "",
},
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
})
Describe(`Service constructor tests using external config`, func() {
Context(`Using external config, construct service client instances`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "noauth",
}
It(`Create service client using external config successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url from constructor successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://testService/api",
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url programatically successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("https://testService/api")
Expect(err).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
})
Context(`Using external config, construct service client instances with error: Invalid Auth`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "someOtherAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
Context(`Using external config, construct service client instances with error: Invalid URL`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "NOAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
})
Describe(`Regional endpoint tests`, func() {
It(`GetServiceURLForRegion(region string)`, func() {
var url string
var err error
url, err = ibmcloudobjectstorages3apiv2.GetServiceURLForRegion("INVALID_REGION")
Expect(url).To(BeEmpty())
Expect(err).ToNot(BeNil())
fmt.Fprintf(GinkgoWriter, "Expected error: %s\n", err.Error())
})
})
Describe(`PutBucketLifecycleConfiguration(putBucketLifecycleConfigurationOptions *PutBucketLifecycleConfigurationOptions)`, func() {
putBucketLifecycleConfigurationPath := "/testString?lifecycle"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(putBucketLifecycleConfigurationPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
// TODO: Add check for lifecycle query parameter
res.WriteHeader(200)
}))
})
It(`Invoke PutBucketLifecycleConfiguration successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.PutBucketLifecycleConfiguration(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the PutBucketLifecycleConfigurationOptions model
putBucketLifecycleConfigurationOptionsModel := new(ibmcloudobjectstorages3apiv2.PutBucketLifecycleConfigurationOptions)
putBucketLifecycleConfigurationOptionsModel.Bucket = core.StringPtr("testString")
putBucketLifecycleConfigurationOptionsModel.Lifecycle = core.BoolPtr(true)
putBucketLifecycleConfigurationOptionsModel.Body = core.StringPtr("testString")
putBucketLifecycleConfigurationOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutBucketLifecycleConfiguration(putBucketLifecycleConfigurationOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke PutBucketLifecycleConfiguration with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the PutBucketLifecycleConfigurationOptions model
putBucketLifecycleConfigurationOptionsModel := new(ibmcloudobjectstorages3apiv2.PutBucketLifecycleConfigurationOptions)
putBucketLifecycleConfigurationOptionsModel.Bucket = core.StringPtr("testString")
putBucketLifecycleConfigurationOptionsModel.Lifecycle = core.BoolPtr(true)
putBucketLifecycleConfigurationOptionsModel.Body = core.StringPtr("testString")
putBucketLifecycleConfigurationOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.PutBucketLifecycleConfiguration(putBucketLifecycleConfigurationOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the PutBucketLifecycleConfigurationOptions model with no property values
putBucketLifecycleConfigurationOptionsModelNew := new(ibmcloudobjectstorages3apiv2.PutBucketLifecycleConfigurationOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutBucketLifecycleConfiguration(putBucketLifecycleConfigurationOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationOptions *GetBucketLifecycleConfigurationOptions) - Operation response error`, func() {
getBucketLifecycleConfigurationPath := "/testString?lifecycle"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getBucketLifecycleConfigurationPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for lifecycle query parameter
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke GetBucketLifecycleConfiguration with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetBucketLifecycleConfigurationOptions model
getBucketLifecycleConfigurationOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketLifecycleConfigurationOptions)
getBucketLifecycleConfigurationOptionsModel.Bucket = core.StringPtr("testString")
getBucketLifecycleConfigurationOptionsModel.Lifecycle = core.BoolPtr(true)
getBucketLifecycleConfigurationOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationOptions *GetBucketLifecycleConfigurationOptions)`, func() {
getBucketLifecycleConfigurationPath := "/testString?lifecycle"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getBucketLifecycleConfigurationPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for lifecycle query parameter
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Rules": {}}`)
}))
})
It(`Invoke GetBucketLifecycleConfiguration successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the GetBucketLifecycleConfigurationOptions model
getBucketLifecycleConfigurationOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketLifecycleConfigurationOptions)
getBucketLifecycleConfigurationOptionsModel.Bucket = core.StringPtr("testString")
getBucketLifecycleConfigurationOptionsModel.Lifecycle = core.BoolPtr(true)
getBucketLifecycleConfigurationOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketLifecycleConfigurationWithContext(ctx, getBucketLifecycleConfigurationOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketLifecycleConfigurationWithContext(ctx, getBucketLifecycleConfigurationOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getBucketLifecycleConfigurationPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for lifecycle query parameter
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Rules": {}}`)
}))
})
It(`Invoke GetBucketLifecycleConfiguration successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketLifecycleConfiguration(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the GetBucketLifecycleConfigurationOptions model
getBucketLifecycleConfigurationOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketLifecycleConfigurationOptions)
getBucketLifecycleConfigurationOptionsModel.Bucket = core.StringPtr("testString")
getBucketLifecycleConfigurationOptionsModel.Lifecycle = core.BoolPtr(true)
getBucketLifecycleConfigurationOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke GetBucketLifecycleConfiguration with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetBucketLifecycleConfigurationOptions model
getBucketLifecycleConfigurationOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketLifecycleConfigurationOptions)
getBucketLifecycleConfigurationOptionsModel.Bucket = core.StringPtr("testString")
getBucketLifecycleConfigurationOptionsModel.Lifecycle = core.BoolPtr(true)
getBucketLifecycleConfigurationOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the GetBucketLifecycleConfigurationOptions model with no property values
getBucketLifecycleConfigurationOptionsModelNew := new(ibmcloudobjectstorages3apiv2.GetBucketLifecycleConfigurationOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`DeleteBucketLifecycle(deleteBucketLifecycleOptions *DeleteBucketLifecycleOptions)`, func() {
deleteBucketLifecyclePath := "/testString?lifecycle"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(deleteBucketLifecyclePath))
Expect(req.Method).To(Equal("DELETE"))
// TODO: Add check for lifecycle query parameter
res.WriteHeader(204)
}))
})
It(`Invoke DeleteBucketLifecycle successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteBucketLifecycle(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the DeleteBucketLifecycleOptions model
deleteBucketLifecycleOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteBucketLifecycleOptions)
deleteBucketLifecycleOptionsModel.Bucket = core.StringPtr("testString")
deleteBucketLifecycleOptionsModel.Lifecycle = core.BoolPtr(true)
deleteBucketLifecycleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteBucketLifecycle(deleteBucketLifecycleOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke DeleteBucketLifecycle with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the DeleteBucketLifecycleOptions model
deleteBucketLifecycleOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteBucketLifecycleOptions)
deleteBucketLifecycleOptionsModel.Bucket = core.StringPtr("testString")
deleteBucketLifecycleOptionsModel.Lifecycle = core.BoolPtr(true)
deleteBucketLifecycleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteBucketLifecycle(deleteBucketLifecycleOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the DeleteBucketLifecycleOptions model with no property values
deleteBucketLifecycleOptionsModelNew := new(ibmcloudobjectstorages3apiv2.DeleteBucketLifecycleOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteBucketLifecycle(deleteBucketLifecycleOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`RestoreObject(restoreObjectOptions *RestoreObjectOptions)`, func() {
restoreObjectPath := "/testString/testString?restore"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(restoreObjectPath))
Expect(req.Method).To(Equal("POST"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
// TODO: Add check for restore query parameter
res.WriteHeader(200)
}))
})
It(`Invoke RestoreObject successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.RestoreObject(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the RestoreObjectOptions model
restoreObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.RestoreObjectOptions)
restoreObjectOptionsModel.Bucket = core.StringPtr("testString")
restoreObjectOptionsModel.Key = core.StringPtr("testString")
restoreObjectOptionsModel.Restore = core.BoolPtr(true)
restoreObjectOptionsModel.Body = core.StringPtr("testString")
restoreObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.RestoreObject(restoreObjectOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke RestoreObject with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the RestoreObjectOptions model
restoreObjectOptionsModel := new(ibmcloudobjectstorages3apiv2.RestoreObjectOptions)
restoreObjectOptionsModel.Bucket = core.StringPtr("testString")
restoreObjectOptionsModel.Key = core.StringPtr("testString")
restoreObjectOptionsModel.Restore = core.BoolPtr(true)
restoreObjectOptionsModel.Body = core.StringPtr("testString")
restoreObjectOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.RestoreObject(restoreObjectOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the RestoreObjectOptions model with no property values
restoreObjectOptionsModelNew := new(ibmcloudobjectstorages3apiv2.RestoreObjectOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.RestoreObject(restoreObjectOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`Service constructor tests`, func() {
It(`Instantiate service client`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
})
It(`Instantiate service client with error: Invalid URL`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
It(`Instantiate service client with error: Invalid Auth`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://ibmcloudobjectstorages3apiv2/api",
Authenticator: &core.BasicAuthenticator{
Username: "",
Password: "",
},
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
})
Describe(`Service constructor tests using external config`, func() {
Context(`Using external config, construct service client instances`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "noauth",
}
It(`Create service client using external config successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url from constructor successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://testService/api",
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url programatically successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("https://testService/api")
Expect(err).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
})
Context(`Using external config, construct service client instances with error: Invalid Auth`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "someOtherAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
Context(`Using external config, construct service client instances with error: Invalid URL`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "NOAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
})
Describe(`Regional endpoint tests`, func() {
It(`GetServiceURLForRegion(region string)`, func() {
var url string
var err error
url, err = ibmcloudobjectstorages3apiv2.GetServiceURLForRegion("INVALID_REGION")
Expect(url).To(BeEmpty())
Expect(err).ToNot(BeNil())
fmt.Fprintf(GinkgoWriter, "Expected error: %s\n", err.Error())
})
})
Describe(`InitiateMultipartUpload(initiateMultipartUploadOptions *InitiateMultipartUploadOptions) - Operation response error`, func() {
initiateMultipartUploadPath := "/testString/testString?uploads"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(initiateMultipartUploadPath))
Expect(req.Method).To(Equal("POST"))
Expect(req.Header["If-Match"]).ToNot(BeNil())
Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-None-Match"]).ToNot(BeNil())
Expect(req.Header["If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Cache-Control"]).ToNot(BeNil())
Expect(req.Header["Cache-Control"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Disposition"]).ToNot(BeNil())
Expect(req.Header["Content-Disposition"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Encoding"]).ToNot(BeNil())
Expect(req.Header["Content-Encoding"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Language"]).ToNot(BeNil())
Expect(req.Header["Content-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Expires"]).ToNot(BeNil())
Expect(req.Header["Expires"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Server-Side-Encryption"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption"][0]).To(Equal(fmt.Sprintf("%v", "AES256")))
Expect(req.Header["X-Amz-Website-Redirect-Location"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Website-Redirect-Location"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Tagging"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Tagging"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Acl"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Acl"][0]).To(Equal(fmt.Sprintf("%v", "private")))
// TODO: Add check for uploads query parameter
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke InitiateMultipartUpload with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the InitiateMultipartUploadOptions model
initiateMultipartUploadOptionsModel := new(ibmcloudobjectstorages3apiv2.InitiateMultipartUploadOptions)
initiateMultipartUploadOptionsModel.Bucket = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Uploads = core.BoolPtr(true)
initiateMultipartUploadOptionsModel.Key = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Body = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfMatch = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfNoneMatch = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
initiateMultipartUploadOptionsModel.CacheControl = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentDisposition = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentEncoding = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentLanguage = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Expires = CreateMockDateTime()
initiateMultipartUploadOptionsModel.XAmzServerSideEncryption = core.StringPtr("AES256")
initiateMultipartUploadOptionsModel.XAmzWebsiteRedirectLocation = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzTagging = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzAcl = core.StringPtr("private")
initiateMultipartUploadOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.InitiateMultipartUpload(initiateMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.InitiateMultipartUpload(initiateMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`InitiateMultipartUpload(initiateMultipartUploadOptions *InitiateMultipartUploadOptions)`, func() {
initiateMultipartUploadPath := "/testString/testString?uploads"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(initiateMultipartUploadPath))
Expect(req.Method).To(Equal("POST"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["If-Match"]).ToNot(BeNil())
Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-None-Match"]).ToNot(BeNil())
Expect(req.Header["If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Cache-Control"]).ToNot(BeNil())
Expect(req.Header["Cache-Control"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Disposition"]).ToNot(BeNil())
Expect(req.Header["Content-Disposition"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Encoding"]).ToNot(BeNil())
Expect(req.Header["Content-Encoding"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Language"]).ToNot(BeNil())
Expect(req.Header["Content-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Expires"]).ToNot(BeNil())
Expect(req.Header["Expires"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Server-Side-Encryption"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption"][0]).To(Equal(fmt.Sprintf("%v", "AES256")))
Expect(req.Header["X-Amz-Website-Redirect-Location"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Website-Redirect-Location"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Tagging"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Tagging"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Acl"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Acl"][0]).To(Equal(fmt.Sprintf("%v", "private")))
// TODO: Add check for uploads query parameter
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Bucket": "Bucket", "Key": "Key", "UploadId": "UploadID"}`)
}))
})
It(`Invoke InitiateMultipartUpload successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the InitiateMultipartUploadOptions model
initiateMultipartUploadOptionsModel := new(ibmcloudobjectstorages3apiv2.InitiateMultipartUploadOptions)
initiateMultipartUploadOptionsModel.Bucket = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Uploads = core.BoolPtr(true)
initiateMultipartUploadOptionsModel.Key = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Body = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfMatch = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfNoneMatch = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
initiateMultipartUploadOptionsModel.CacheControl = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentDisposition = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentEncoding = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentLanguage = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Expires = CreateMockDateTime()
initiateMultipartUploadOptionsModel.XAmzServerSideEncryption = core.StringPtr("AES256")
initiateMultipartUploadOptionsModel.XAmzWebsiteRedirectLocation = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzTagging = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzAcl = core.StringPtr("private")
initiateMultipartUploadOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.InitiateMultipartUploadWithContext(ctx, initiateMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.InitiateMultipartUpload(initiateMultipartUploadOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.InitiateMultipartUploadWithContext(ctx, initiateMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(initiateMultipartUploadPath))
Expect(req.Method).To(Equal("POST"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["If-Match"]).ToNot(BeNil())
Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-None-Match"]).ToNot(BeNil())
Expect(req.Header["If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["Cache-Control"]).ToNot(BeNil())
Expect(req.Header["Cache-Control"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Disposition"]).ToNot(BeNil())
Expect(req.Header["Content-Disposition"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Encoding"]).ToNot(BeNil())
Expect(req.Header["Content-Encoding"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Content-Language"]).ToNot(BeNil())
Expect(req.Header["Content-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["Expires"]).ToNot(BeNil())
Expect(req.Header["Expires"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Server-Side-Encryption"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption"][0]).To(Equal(fmt.Sprintf("%v", "AES256")))
Expect(req.Header["X-Amz-Website-Redirect-Location"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Website-Redirect-Location"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Tagging"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Tagging"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Acl"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Acl"][0]).To(Equal(fmt.Sprintf("%v", "private")))
// TODO: Add check for uploads query parameter
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Bucket": "Bucket", "Key": "Key", "UploadId": "UploadID"}`)
}))
})
It(`Invoke InitiateMultipartUpload successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.InitiateMultipartUpload(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the InitiateMultipartUploadOptions model
initiateMultipartUploadOptionsModel := new(ibmcloudobjectstorages3apiv2.InitiateMultipartUploadOptions)
initiateMultipartUploadOptionsModel.Bucket = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Uploads = core.BoolPtr(true)
initiateMultipartUploadOptionsModel.Key = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Body = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfMatch = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfNoneMatch = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
initiateMultipartUploadOptionsModel.CacheControl = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentDisposition = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentEncoding = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentLanguage = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Expires = CreateMockDateTime()
initiateMultipartUploadOptionsModel.XAmzServerSideEncryption = core.StringPtr("AES256")
initiateMultipartUploadOptionsModel.XAmzWebsiteRedirectLocation = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzTagging = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzAcl = core.StringPtr("private")
initiateMultipartUploadOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.InitiateMultipartUpload(initiateMultipartUploadOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke InitiateMultipartUpload with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the InitiateMultipartUploadOptions model
initiateMultipartUploadOptionsModel := new(ibmcloudobjectstorages3apiv2.InitiateMultipartUploadOptions)
initiateMultipartUploadOptionsModel.Bucket = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Uploads = core.BoolPtr(true)
initiateMultipartUploadOptionsModel.Key = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Body = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfMatch = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfNoneMatch = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.IfUnmodifiedSince = CreateMockDateTime()
initiateMultipartUploadOptionsModel.CacheControl = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentDisposition = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentEncoding = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.ContentLanguage = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.Expires = CreateMockDateTime()
initiateMultipartUploadOptionsModel.XAmzServerSideEncryption = core.StringPtr("AES256")
initiateMultipartUploadOptionsModel.XAmzWebsiteRedirectLocation = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzTagging = core.StringPtr("testString")
initiateMultipartUploadOptionsModel.XAmzAcl = core.StringPtr("private")
initiateMultipartUploadOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.InitiateMultipartUpload(initiateMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the InitiateMultipartUploadOptions model with no property values
initiateMultipartUploadOptionsModelNew := new(ibmcloudobjectstorages3apiv2.InitiateMultipartUploadOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.InitiateMultipartUpload(initiateMultipartUploadOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`CompleteMultipartUpload(completeMultipartUploadOptions *CompleteMultipartUploadOptions) - Operation response error`, func() {
completeMultipartUploadPath := "/testString/testString?uploadId={uploadId}"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(completeMultipartUploadPath))
Expect(req.Method).To(Equal("POST"))
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke CompleteMultipartUpload with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the CompleteMultipartUploadOptions model
completeMultipartUploadOptionsModel := new(ibmcloudobjectstorages3apiv2.CompleteMultipartUploadOptions)
completeMultipartUploadOptionsModel.Bucket = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Key = core.StringPtr("testString")
completeMultipartUploadOptionsModel.UploadID = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Body = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.CompleteMultipartUpload(completeMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.CompleteMultipartUpload(completeMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`CompleteMultipartUpload(completeMultipartUploadOptions *CompleteMultipartUploadOptions)`, func() {
completeMultipartUploadPath := "/testString/testString?uploadId={uploadId}"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(completeMultipartUploadPath))
Expect(req.Method).To(Equal("POST"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Location": "Location", "Bucket": "Bucket", "Key": "Key", "ETag": "ETag"}`)
}))
})
It(`Invoke CompleteMultipartUpload successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the CompleteMultipartUploadOptions model
completeMultipartUploadOptionsModel := new(ibmcloudobjectstorages3apiv2.CompleteMultipartUploadOptions)
completeMultipartUploadOptionsModel.Bucket = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Key = core.StringPtr("testString")
completeMultipartUploadOptionsModel.UploadID = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Body = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.CompleteMultipartUploadWithContext(ctx, completeMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.CompleteMultipartUpload(completeMultipartUploadOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.CompleteMultipartUploadWithContext(ctx, completeMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(completeMultipartUploadPath))
Expect(req.Method).To(Equal("POST"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Location": "Location", "Bucket": "Bucket", "Key": "Key", "ETag": "ETag"}`)
}))
})
It(`Invoke CompleteMultipartUpload successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.CompleteMultipartUpload(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the CompleteMultipartUploadOptions model
completeMultipartUploadOptionsModel := new(ibmcloudobjectstorages3apiv2.CompleteMultipartUploadOptions)
completeMultipartUploadOptionsModel.Bucket = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Key = core.StringPtr("testString")
completeMultipartUploadOptionsModel.UploadID = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Body = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.CompleteMultipartUpload(completeMultipartUploadOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke CompleteMultipartUpload with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the CompleteMultipartUploadOptions model
completeMultipartUploadOptionsModel := new(ibmcloudobjectstorages3apiv2.CompleteMultipartUploadOptions)
completeMultipartUploadOptionsModel.Bucket = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Key = core.StringPtr("testString")
completeMultipartUploadOptionsModel.UploadID = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Body = core.StringPtr("testString")
completeMultipartUploadOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.CompleteMultipartUpload(completeMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the CompleteMultipartUploadOptions model with no property values
completeMultipartUploadOptionsModelNew := new(ibmcloudobjectstorages3apiv2.CompleteMultipartUploadOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.CompleteMultipartUpload(completeMultipartUploadOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`ListParts(listPartsOptions *ListPartsOptions) - Operation response error`, func() {
listPartsPath := "/testString/testString?uploadId={uploadId}"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listPartsPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["max-parts"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["part-number-marker"]).To(Equal([]string{fmt.Sprint(int64(38))}))
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke ListParts with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the ListPartsOptions model
listPartsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListPartsOptions)
listPartsOptionsModel.Bucket = core.StringPtr("testString")
listPartsOptionsModel.Key = core.StringPtr("testString")
listPartsOptionsModel.UploadID = core.StringPtr("testString")
listPartsOptionsModel.MaxParts = core.Int64Ptr(int64(38))
listPartsOptionsModel.PartNumberMarker = core.Int64Ptr(int64(38))
listPartsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListParts(listPartsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListParts(listPartsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`ListParts(listPartsOptions *ListPartsOptions)`, func() {
listPartsPath := "/testString/testString?uploadId={uploadId}"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listPartsPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["max-parts"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["part-number-marker"]).To(Equal([]string{fmt.Sprint(int64(38))}))
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Bucket": "Bucket", "Key": "Key", "UploadId": "UploadID", "PartNumberMarker": 16, "NextPartNumberMarker": 20, "MaxParts": 8, "IsTruncated": false, "Parts": {}, "Initiator": {"ID": "ID", "DisplayName": "DisplayName"}, "Owner": {"DisplayName": "DisplayName", "ID": "ID"}, "StorageClass": "STANDARD"}`)
}))
})
It(`Invoke ListParts successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the ListPartsOptions model
listPartsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListPartsOptions)
listPartsOptionsModel.Bucket = core.StringPtr("testString")
listPartsOptionsModel.Key = core.StringPtr("testString")
listPartsOptionsModel.UploadID = core.StringPtr("testString")
listPartsOptionsModel.MaxParts = core.Int64Ptr(int64(38))
listPartsOptionsModel.PartNumberMarker = core.Int64Ptr(int64(38))
listPartsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.ListPartsWithContext(ctx, listPartsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListParts(listPartsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.ListPartsWithContext(ctx, listPartsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listPartsPath))
Expect(req.Method).To(Equal("GET"))
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["max-parts"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["part-number-marker"]).To(Equal([]string{fmt.Sprint(int64(38))}))
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Bucket": "Bucket", "Key": "Key", "UploadId": "UploadID", "PartNumberMarker": 16, "NextPartNumberMarker": 20, "MaxParts": 8, "IsTruncated": false, "Parts": {}, "Initiator": {"ID": "ID", "DisplayName": "DisplayName"}, "Owner": {"DisplayName": "DisplayName", "ID": "ID"}, "StorageClass": "STANDARD"}`)
}))
})
It(`Invoke ListParts successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListParts(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the ListPartsOptions model
listPartsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListPartsOptions)
listPartsOptionsModel.Bucket = core.StringPtr("testString")
listPartsOptionsModel.Key = core.StringPtr("testString")
listPartsOptionsModel.UploadID = core.StringPtr("testString")
listPartsOptionsModel.MaxParts = core.Int64Ptr(int64(38))
listPartsOptionsModel.PartNumberMarker = core.Int64Ptr(int64(38))
listPartsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListParts(listPartsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke ListParts with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the ListPartsOptions model
listPartsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListPartsOptions)
listPartsOptionsModel.Bucket = core.StringPtr("testString")
listPartsOptionsModel.Key = core.StringPtr("testString")
listPartsOptionsModel.UploadID = core.StringPtr("testString")
listPartsOptionsModel.MaxParts = core.Int64Ptr(int64(38))
listPartsOptionsModel.PartNumberMarker = core.Int64Ptr(int64(38))
listPartsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListParts(listPartsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the ListPartsOptions model with no property values
listPartsOptionsModelNew := new(ibmcloudobjectstorages3apiv2.ListPartsOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListParts(listPartsOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`AbortMultipartUpload(abortMultipartUploadOptions *AbortMultipartUploadOptions)`, func() {
abortMultipartUploadPath := "/testString/testString?uploadId={uploadId}"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(abortMultipartUploadPath))
Expect(req.Method).To(Equal("DELETE"))
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
res.WriteHeader(204)
}))
})
It(`Invoke AbortMultipartUpload successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.AbortMultipartUpload(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the AbortMultipartUploadOptions model
abortMultipartUploadOptionsModel := new(ibmcloudobjectstorages3apiv2.AbortMultipartUploadOptions)
abortMultipartUploadOptionsModel.Bucket = core.StringPtr("testString")
abortMultipartUploadOptionsModel.Key = core.StringPtr("testString")
abortMultipartUploadOptionsModel.UploadID = core.StringPtr("testString")
abortMultipartUploadOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.AbortMultipartUpload(abortMultipartUploadOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke AbortMultipartUpload with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the AbortMultipartUploadOptions model
abortMultipartUploadOptionsModel := new(ibmcloudobjectstorages3apiv2.AbortMultipartUploadOptions)
abortMultipartUploadOptionsModel.Bucket = core.StringPtr("testString")
abortMultipartUploadOptionsModel.Key = core.StringPtr("testString")
abortMultipartUploadOptionsModel.UploadID = core.StringPtr("testString")
abortMultipartUploadOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.AbortMultipartUpload(abortMultipartUploadOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the AbortMultipartUploadOptions model with no property values
abortMultipartUploadOptionsModelNew := new(ibmcloudobjectstorages3apiv2.AbortMultipartUploadOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.AbortMultipartUpload(abortMultipartUploadOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`ListMultipartUploads(listMultipartUploadsOptions *ListMultipartUploadsOptions) - Operation response error`, func() {
listMultipartUploadsPath := "/testString?uploads"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listMultipartUploadsPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for uploads query parameter
Expect(req.URL.Query()["delimiter"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["encoding-type"]).To(Equal([]string{"url"}))
Expect(req.URL.Query()["key-marker"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["max-uploads"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["prefix"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["upload-id-marker"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["PaginationLimit"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["PaginationToken"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["PaginationToken"]).To(Equal([]string{"testString"}))
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke ListMultipartUploads with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the ListMultipartUploadsOptions model
listMultipartUploadsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListMultipartUploadsOptions)
listMultipartUploadsOptionsModel.Bucket = core.StringPtr("testString")
listMultipartUploadsOptionsModel.Uploads = core.BoolPtr(true)
listMultipartUploadsOptionsModel.Delimiter = core.StringPtr("testString")
listMultipartUploadsOptionsModel.EncodingType = core.StringPtr("url")
listMultipartUploadsOptionsModel.KeyMarker = core.StringPtr("testString")
listMultipartUploadsOptionsModel.MaxUploads = core.Int64Ptr(int64(38))
listMultipartUploadsOptionsModel.Prefix = core.StringPtr("testString")
listMultipartUploadsOptionsModel.UploadIdMarker = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationLimit = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationToken = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationToken = core.StringPtr("testString")
listMultipartUploadsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListMultipartUploads(listMultipartUploadsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListMultipartUploads(listMultipartUploadsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`ListMultipartUploads(listMultipartUploadsOptions *ListMultipartUploadsOptions)`, func() {
listMultipartUploadsPath := "/testString?uploads"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listMultipartUploadsPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for uploads query parameter
Expect(req.URL.Query()["delimiter"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["encoding-type"]).To(Equal([]string{"url"}))
Expect(req.URL.Query()["key-marker"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["max-uploads"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["prefix"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["upload-id-marker"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["PaginationLimit"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["PaginationToken"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["PaginationToken"]).To(Equal([]string{"testString"}))
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Bucket": "Bucket", "KeyMarker": "KeyMarker", "UploadIdMarker": "UploadIdMarker", "NextKeyMarker": "NextKeyMarker", "Prefix": "Prefix", "Delimiter": "Delimiter", "NextUploadIdMarker": "NextUploadIdMarker", "MaxUploads": 10, "IsTruncated": false, "Uploads": {}, "CommonPrefixes": {}, "EncodingType": "url"}`)
}))
})
It(`Invoke ListMultipartUploads successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the ListMultipartUploadsOptions model
listMultipartUploadsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListMultipartUploadsOptions)
listMultipartUploadsOptionsModel.Bucket = core.StringPtr("testString")
listMultipartUploadsOptionsModel.Uploads = core.BoolPtr(true)
listMultipartUploadsOptionsModel.Delimiter = core.StringPtr("testString")
listMultipartUploadsOptionsModel.EncodingType = core.StringPtr("url")
listMultipartUploadsOptionsModel.KeyMarker = core.StringPtr("testString")
listMultipartUploadsOptionsModel.MaxUploads = core.Int64Ptr(int64(38))
listMultipartUploadsOptionsModel.Prefix = core.StringPtr("testString")
listMultipartUploadsOptionsModel.UploadIdMarker = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationLimit = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationToken = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationToken = core.StringPtr("testString")
listMultipartUploadsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.ListMultipartUploadsWithContext(ctx, listMultipartUploadsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListMultipartUploads(listMultipartUploadsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.ListMultipartUploadsWithContext(ctx, listMultipartUploadsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(listMultipartUploadsPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for uploads query parameter
Expect(req.URL.Query()["delimiter"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["encoding-type"]).To(Equal([]string{"url"}))
Expect(req.URL.Query()["key-marker"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["max-uploads"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["prefix"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["upload-id-marker"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["PaginationLimit"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["PaginationToken"]).To(Equal([]string{"testString"}))
Expect(req.URL.Query()["PaginationToken"]).To(Equal([]string{"testString"}))
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Bucket": "Bucket", "KeyMarker": "KeyMarker", "UploadIdMarker": "UploadIdMarker", "NextKeyMarker": "NextKeyMarker", "Prefix": "Prefix", "Delimiter": "Delimiter", "NextUploadIdMarker": "NextUploadIdMarker", "MaxUploads": 10, "IsTruncated": false, "Uploads": {}, "CommonPrefixes": {}, "EncodingType": "url"}`)
}))
})
It(`Invoke ListMultipartUploads successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListMultipartUploads(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the ListMultipartUploadsOptions model
listMultipartUploadsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListMultipartUploadsOptions)
listMultipartUploadsOptionsModel.Bucket = core.StringPtr("testString")
listMultipartUploadsOptionsModel.Uploads = core.BoolPtr(true)
listMultipartUploadsOptionsModel.Delimiter = core.StringPtr("testString")
listMultipartUploadsOptionsModel.EncodingType = core.StringPtr("url")
listMultipartUploadsOptionsModel.KeyMarker = core.StringPtr("testString")
listMultipartUploadsOptionsModel.MaxUploads = core.Int64Ptr(int64(38))
listMultipartUploadsOptionsModel.Prefix = core.StringPtr("testString")
listMultipartUploadsOptionsModel.UploadIdMarker = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationLimit = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationToken = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationToken = core.StringPtr("testString")
listMultipartUploadsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListMultipartUploads(listMultipartUploadsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke ListMultipartUploads with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the ListMultipartUploadsOptions model
listMultipartUploadsOptionsModel := new(ibmcloudobjectstorages3apiv2.ListMultipartUploadsOptions)
listMultipartUploadsOptionsModel.Bucket = core.StringPtr("testString")
listMultipartUploadsOptionsModel.Uploads = core.BoolPtr(true)
listMultipartUploadsOptionsModel.Delimiter = core.StringPtr("testString")
listMultipartUploadsOptionsModel.EncodingType = core.StringPtr("url")
listMultipartUploadsOptionsModel.KeyMarker = core.StringPtr("testString")
listMultipartUploadsOptionsModel.MaxUploads = core.Int64Ptr(int64(38))
listMultipartUploadsOptionsModel.Prefix = core.StringPtr("testString")
listMultipartUploadsOptionsModel.UploadIdMarker = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationLimit = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationToken = core.StringPtr("testString")
listMultipartUploadsOptionsModel.PaginationToken = core.StringPtr("testString")
listMultipartUploadsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.ListMultipartUploads(listMultipartUploadsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the ListMultipartUploadsOptions model with no property values
listMultipartUploadsOptionsModelNew := new(ibmcloudobjectstorages3apiv2.ListMultipartUploadsOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.ListMultipartUploads(listMultipartUploadsOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`UploadPart(uploadPartOptions *UploadPartOptions)`, func() {
uploadPartPath := "/testString/testString?partNumber={partNumber}&uploadId={uploadId}"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(uploadPartPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["Content-Length"]).ToNot(BeNil())
Expect(req.Header["Content-Length"][0]).To(Equal(fmt.Sprintf("%v", int64(38))))
Expect(req.Header["Content-Md5"]).ToNot(BeNil())
Expect(req.Header["Content-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Request-Payer"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Request-Payer"][0]).To(Equal(fmt.Sprintf("%v", "requester")))
Expect(req.Header["X-Amz-Expected-Bucket-Owner"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Expected-Bucket-Owner"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.URL.Query()["partNumber"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
res.WriteHeader(200)
}))
})
It(`Invoke UploadPart successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.UploadPart(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the UploadPartOptions model
uploadPartOptionsModel := new(ibmcloudobjectstorages3apiv2.UploadPartOptions)
uploadPartOptionsModel.Bucket = core.StringPtr("testString")
uploadPartOptionsModel.Key = core.StringPtr("testString")
uploadPartOptionsModel.PartNumber = core.Int64Ptr(int64(38))
uploadPartOptionsModel.UploadID = core.StringPtr("testString")
uploadPartOptionsModel.Body = core.StringPtr("testString")
uploadPartOptionsModel.ContentLength = core.Int64Ptr(int64(38))
uploadPartOptionsModel.ContentMD5 = core.StringPtr("testString")
uploadPartOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
uploadPartOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
uploadPartOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
uploadPartOptionsModel.XAmzRequestPayer = core.StringPtr("requester")
uploadPartOptionsModel.XAmzExpectedBucketOwner = core.StringPtr("testString")
uploadPartOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.UploadPart(uploadPartOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke UploadPart with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the UploadPartOptions model
uploadPartOptionsModel := new(ibmcloudobjectstorages3apiv2.UploadPartOptions)
uploadPartOptionsModel.Bucket = core.StringPtr("testString")
uploadPartOptionsModel.Key = core.StringPtr("testString")
uploadPartOptionsModel.PartNumber = core.Int64Ptr(int64(38))
uploadPartOptionsModel.UploadID = core.StringPtr("testString")
uploadPartOptionsModel.Body = core.StringPtr("testString")
uploadPartOptionsModel.ContentLength = core.Int64Ptr(int64(38))
uploadPartOptionsModel.ContentMD5 = core.StringPtr("testString")
uploadPartOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
uploadPartOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
uploadPartOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
uploadPartOptionsModel.XAmzRequestPayer = core.StringPtr("requester")
uploadPartOptionsModel.XAmzExpectedBucketOwner = core.StringPtr("testString")
uploadPartOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.UploadPart(uploadPartOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the UploadPartOptions model with no property values
uploadPartOptionsModelNew := new(ibmcloudobjectstorages3apiv2.UploadPartOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.UploadPart(uploadPartOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`UploadPartCopy(uploadPartCopyOptions *UploadPartCopyOptions) - Operation response error`, func() {
uploadPartCopyPath := "/testString/{TargetKey}?partNumber={partNumber}&uploadId={uploadId}"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(uploadPartCopyPath))
Expect(req.Method).To(Equal("PUT"))
Expect(req.Header["X-Amz-Copy-Source"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Copy-Source-Range"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Range"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.URL.Query()["partNumber"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke UploadPartCopy with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the UploadPartCopyOptions model
uploadPartCopyOptionsModel := new(ibmcloudobjectstorages3apiv2.UploadPartCopyOptions)
uploadPartCopyOptionsModel.Bucket = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySource = core.StringPtr("testString")
uploadPartCopyOptionsModel.Key = core.StringPtr("testString")
uploadPartCopyOptionsModel.PartNumber = core.Int64Ptr(int64(38))
uploadPartCopyOptionsModel.UploadID = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfMatch = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfModifiedSince = CreateMockDateTime()
uploadPartCopyOptionsModel.XAmzCopySourceIfNoneMatch = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfUnmodifiedSince = CreateMockDateTime()
uploadPartCopyOptionsModel.XAmzCopySourceRange = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKey = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
uploadPartCopyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.UploadPartCopy(uploadPartCopyOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.UploadPartCopy(uploadPartCopyOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`UploadPartCopy(uploadPartCopyOptions *UploadPartCopyOptions)`, func() {
uploadPartCopyPath := "/testString/{TargetKey}?partNumber={partNumber}&uploadId={uploadId}"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(uploadPartCopyPath))
Expect(req.Method).To(Equal("PUT"))
Expect(req.Header["X-Amz-Copy-Source"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Copy-Source-Range"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Range"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.URL.Query()["partNumber"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"CopyPartResult": {"ETag": "ETag", "LastModified": "2019-01-01T12:00:00.000Z"}}`)
}))
})
It(`Invoke UploadPartCopy successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the UploadPartCopyOptions model
uploadPartCopyOptionsModel := new(ibmcloudobjectstorages3apiv2.UploadPartCopyOptions)
uploadPartCopyOptionsModel.Bucket = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySource = core.StringPtr("testString")
uploadPartCopyOptionsModel.Key = core.StringPtr("testString")
uploadPartCopyOptionsModel.PartNumber = core.Int64Ptr(int64(38))
uploadPartCopyOptionsModel.UploadID = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfMatch = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfModifiedSince = CreateMockDateTime()
uploadPartCopyOptionsModel.XAmzCopySourceIfNoneMatch = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfUnmodifiedSince = CreateMockDateTime()
uploadPartCopyOptionsModel.XAmzCopySourceRange = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKey = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
uploadPartCopyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.UploadPartCopyWithContext(ctx, uploadPartCopyOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.UploadPartCopy(uploadPartCopyOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.UploadPartCopyWithContext(ctx, uploadPartCopyOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(uploadPartCopyPath))
Expect(req.Method).To(Equal("PUT"))
Expect(req.Header["X-Amz-Copy-Source"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Modified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-None-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-If-Unmodified-Since"][0]).To(Equal(fmt.Sprintf("%v", CreateMockDateTime())))
Expect(req.Header["X-Amz-Copy-Source-Range"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Range"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.URL.Query()["partNumber"]).To(Equal([]string{fmt.Sprint(int64(38))}))
Expect(req.URL.Query()["uploadId"]).To(Equal([]string{"testString"}))
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"CopyPartResult": {"ETag": "ETag", "LastModified": "2019-01-01T12:00:00.000Z"}}`)
}))
})
It(`Invoke UploadPartCopy successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.UploadPartCopy(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the UploadPartCopyOptions model
uploadPartCopyOptionsModel := new(ibmcloudobjectstorages3apiv2.UploadPartCopyOptions)
uploadPartCopyOptionsModel.Bucket = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySource = core.StringPtr("testString")
uploadPartCopyOptionsModel.Key = core.StringPtr("testString")
uploadPartCopyOptionsModel.PartNumber = core.Int64Ptr(int64(38))
uploadPartCopyOptionsModel.UploadID = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfMatch = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfModifiedSince = CreateMockDateTime()
uploadPartCopyOptionsModel.XAmzCopySourceIfNoneMatch = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfUnmodifiedSince = CreateMockDateTime()
uploadPartCopyOptionsModel.XAmzCopySourceRange = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKey = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
uploadPartCopyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.UploadPartCopy(uploadPartCopyOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke UploadPartCopy with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the UploadPartCopyOptions model
uploadPartCopyOptionsModel := new(ibmcloudobjectstorages3apiv2.UploadPartCopyOptions)
uploadPartCopyOptionsModel.Bucket = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySource = core.StringPtr("testString")
uploadPartCopyOptionsModel.Key = core.StringPtr("testString")
uploadPartCopyOptionsModel.PartNumber = core.Int64Ptr(int64(38))
uploadPartCopyOptionsModel.UploadID = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfMatch = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfModifiedSince = CreateMockDateTime()
uploadPartCopyOptionsModel.XAmzCopySourceIfNoneMatch = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceIfUnmodifiedSince = CreateMockDateTime()
uploadPartCopyOptionsModel.XAmzCopySourceRange = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerKey = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerAlgorithm = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKey = core.StringPtr("testString")
uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKeyMD5 = core.StringPtr("testString")
uploadPartCopyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.UploadPartCopy(uploadPartCopyOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the UploadPartCopyOptions model with no property values
uploadPartCopyOptionsModelNew := new(ibmcloudobjectstorages3apiv2.UploadPartCopyOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.UploadPartCopy(uploadPartCopyOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`Service constructor tests`, func() {
It(`Instantiate service client`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
})
It(`Instantiate service client with error: Invalid URL`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
It(`Instantiate service client with error: Invalid Auth`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://ibmcloudobjectstorages3apiv2/api",
Authenticator: &core.BasicAuthenticator{
Username: "",
Password: "",
},
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
})
Describe(`Service constructor tests using external config`, func() {
Context(`Using external config, construct service client instances`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "noauth",
}
It(`Create service client using external config successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url from constructor successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://testService/api",
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url programatically successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("https://testService/api")
Expect(err).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
})
Context(`Using external config, construct service client instances with error: Invalid Auth`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "someOtherAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
Context(`Using external config, construct service client instances with error: Invalid URL`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "NOAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
})
Describe(`Regional endpoint tests`, func() {
It(`GetServiceURLForRegion(region string)`, func() {
var url string
var err error
url, err = ibmcloudobjectstorages3apiv2.GetServiceURLForRegion("INVALID_REGION")
Expect(url).To(BeEmpty())
Expect(err).ToNot(BeNil())
fmt.Fprintf(GinkgoWriter, "Expected error: %s\n", err.Error())
})
})
Describe(`PutPublicAccessBlock(putPublicAccessBlockOptions *PutPublicAccessBlockOptions)`, func() {
putPublicAccessBlockPath := "/testString?publicAccessBlock"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(putPublicAccessBlockPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["Content-Md5"]).ToNot(BeNil())
Expect(req.Header["Content-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
// TODO: Add check for publicAccessBlock query parameter
res.WriteHeader(200)
}))
})
It(`Invoke PutPublicAccessBlock successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.PutPublicAccessBlock(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the PutPublicAccessBlockOptions model
putPublicAccessBlockOptionsModel := new(ibmcloudobjectstorages3apiv2.PutPublicAccessBlockOptions)
putPublicAccessBlockOptionsModel.Bucket = core.StringPtr("testString")
putPublicAccessBlockOptionsModel.PublicAccessBlock = core.BoolPtr(true)
putPublicAccessBlockOptionsModel.Body = core.StringPtr("testString")
putPublicAccessBlockOptionsModel.ContentMD5 = core.StringPtr("testString")
putPublicAccessBlockOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutPublicAccessBlock(putPublicAccessBlockOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke PutPublicAccessBlock with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the PutPublicAccessBlockOptions model
putPublicAccessBlockOptionsModel := new(ibmcloudobjectstorages3apiv2.PutPublicAccessBlockOptions)
putPublicAccessBlockOptionsModel.Bucket = core.StringPtr("testString")
putPublicAccessBlockOptionsModel.PublicAccessBlock = core.BoolPtr(true)
putPublicAccessBlockOptionsModel.Body = core.StringPtr("testString")
putPublicAccessBlockOptionsModel.ContentMD5 = core.StringPtr("testString")
putPublicAccessBlockOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.PutPublicAccessBlock(putPublicAccessBlockOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the PutPublicAccessBlockOptions model with no property values
putPublicAccessBlockOptionsModelNew := new(ibmcloudobjectstorages3apiv2.PutPublicAccessBlockOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutPublicAccessBlock(putPublicAccessBlockOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetPublicAccessBlock(getPublicAccessBlockOptions *GetPublicAccessBlockOptions) - Operation response error`, func() {
getPublicAccessBlockPath := "/testString?publicAccessBlock"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getPublicAccessBlockPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for publicAccessBlock query parameter
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke GetPublicAccessBlock with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetPublicAccessBlockOptions model
getPublicAccessBlockOptionsModel := new(ibmcloudobjectstorages3apiv2.GetPublicAccessBlockOptions)
getPublicAccessBlockOptionsModel.Bucket = core.StringPtr("testString")
getPublicAccessBlockOptionsModel.PublicAccessBlock = core.BoolPtr(true)
getPublicAccessBlockOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetPublicAccessBlock(getPublicAccessBlockOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetPublicAccessBlock(getPublicAccessBlockOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetPublicAccessBlock(getPublicAccessBlockOptions *GetPublicAccessBlockOptions)`, func() {
getPublicAccessBlockPath := "/testString?publicAccessBlock"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getPublicAccessBlockPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for publicAccessBlock query parameter
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"PublicAccessBlockConfiguration": {"BlockPublicAcls": false, "IgnorePublicAcls": true, "BlockPublicPolicy": false, "RestrictPublicBuckets": false}}`)
}))
})
It(`Invoke GetPublicAccessBlock successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the GetPublicAccessBlockOptions model
getPublicAccessBlockOptionsModel := new(ibmcloudobjectstorages3apiv2.GetPublicAccessBlockOptions)
getPublicAccessBlockOptionsModel.Bucket = core.StringPtr("testString")
getPublicAccessBlockOptionsModel.PublicAccessBlock = core.BoolPtr(true)
getPublicAccessBlockOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.GetPublicAccessBlockWithContext(ctx, getPublicAccessBlockOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetPublicAccessBlock(getPublicAccessBlockOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.GetPublicAccessBlockWithContext(ctx, getPublicAccessBlockOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getPublicAccessBlockPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for publicAccessBlock query parameter
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"PublicAccessBlockConfiguration": {"BlockPublicAcls": false, "IgnorePublicAcls": true, "BlockPublicPolicy": false, "RestrictPublicBuckets": false}}`)
}))
})
It(`Invoke GetPublicAccessBlock successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetPublicAccessBlock(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the GetPublicAccessBlockOptions model
getPublicAccessBlockOptionsModel := new(ibmcloudobjectstorages3apiv2.GetPublicAccessBlockOptions)
getPublicAccessBlockOptionsModel.Bucket = core.StringPtr("testString")
getPublicAccessBlockOptionsModel.PublicAccessBlock = core.BoolPtr(true)
getPublicAccessBlockOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetPublicAccessBlock(getPublicAccessBlockOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke GetPublicAccessBlock with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetPublicAccessBlockOptions model
getPublicAccessBlockOptionsModel := new(ibmcloudobjectstorages3apiv2.GetPublicAccessBlockOptions)
getPublicAccessBlockOptionsModel.Bucket = core.StringPtr("testString")
getPublicAccessBlockOptionsModel.PublicAccessBlock = core.BoolPtr(true)
getPublicAccessBlockOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetPublicAccessBlock(getPublicAccessBlockOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the GetPublicAccessBlockOptions model with no property values
getPublicAccessBlockOptionsModelNew := new(ibmcloudobjectstorages3apiv2.GetPublicAccessBlockOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetPublicAccessBlock(getPublicAccessBlockOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`DeletePublicAccessBlock(deletePublicAccessBlockOptions *DeletePublicAccessBlockOptions)`, func() {
deletePublicAccessBlockPath := "/testString?publicAccessBlock"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(deletePublicAccessBlockPath))
Expect(req.Method).To(Equal("DELETE"))
// TODO: Add check for publicAccessBlock query parameter
res.WriteHeader(204)
}))
})
It(`Invoke DeletePublicAccessBlock successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.DeletePublicAccessBlock(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the DeletePublicAccessBlockOptions model
deletePublicAccessBlockOptionsModel := new(ibmcloudobjectstorages3apiv2.DeletePublicAccessBlockOptions)
deletePublicAccessBlockOptionsModel.Bucket = core.StringPtr("testString")
deletePublicAccessBlockOptionsModel.PublicAccessBlock = core.BoolPtr(true)
deletePublicAccessBlockOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeletePublicAccessBlock(deletePublicAccessBlockOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke DeletePublicAccessBlock with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the DeletePublicAccessBlockOptions model
deletePublicAccessBlockOptionsModel := new(ibmcloudobjectstorages3apiv2.DeletePublicAccessBlockOptions)
deletePublicAccessBlockOptionsModel.Bucket = core.StringPtr("testString")
deletePublicAccessBlockOptionsModel.PublicAccessBlock = core.BoolPtr(true)
deletePublicAccessBlockOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.DeletePublicAccessBlock(deletePublicAccessBlockOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the DeletePublicAccessBlockOptions model with no property values
deletePublicAccessBlockOptionsModelNew := new(ibmcloudobjectstorages3apiv2.DeletePublicAccessBlockOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeletePublicAccessBlock(deletePublicAccessBlockOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetBucketAcl(getBucketAclOptions *GetBucketAclOptions)`, func() {
getBucketAclPath := "/testString?acl"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getBucketAclPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for acl query parameter
res.WriteHeader(200)
}))
})
It(`Invoke GetBucketAcl successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketAcl(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the GetBucketAclOptions model
getBucketAclOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketAclOptions)
getBucketAclOptionsModel.Bucket = core.StringPtr("testString")
getBucketAclOptionsModel.Acl = core.BoolPtr(true)
getBucketAclOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketAcl(getBucketAclOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke GetBucketAcl with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetBucketAclOptions model
getBucketAclOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketAclOptions)
getBucketAclOptionsModel.Bucket = core.StringPtr("testString")
getBucketAclOptionsModel.Acl = core.BoolPtr(true)
getBucketAclOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketAcl(getBucketAclOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the GetBucketAclOptions model with no property values
getBucketAclOptionsModelNew := new(ibmcloudobjectstorages3apiv2.GetBucketAclOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketAcl(getBucketAclOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`PutBucketAcl(putBucketAclOptions *PutBucketAclOptions)`, func() {
putBucketAclPath := "/testString?acl"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(putBucketAclPath))
Expect(req.Method).To(Equal("PUT"))
Expect(req.Header["X-Amz-Acl"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Acl"][0]).To(Equal(fmt.Sprintf("%v", "private")))
// TODO: Add check for acl query parameter
res.WriteHeader(200)
}))
})
It(`Invoke PutBucketAcl successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.PutBucketAcl(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the PutBucketAclOptions model
putBucketAclOptionsModel := new(ibmcloudobjectstorages3apiv2.PutBucketAclOptions)
putBucketAclOptionsModel.Bucket = core.StringPtr("testString")
putBucketAclOptionsModel.Acl = core.BoolPtr(true)
putBucketAclOptionsModel.XAmzAcl = core.StringPtr("private")
putBucketAclOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutBucketAcl(putBucketAclOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke PutBucketAcl with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the PutBucketAclOptions model
putBucketAclOptionsModel := new(ibmcloudobjectstorages3apiv2.PutBucketAclOptions)
putBucketAclOptionsModel.Bucket = core.StringPtr("testString")
putBucketAclOptionsModel.Acl = core.BoolPtr(true)
putBucketAclOptionsModel.XAmzAcl = core.StringPtr("private")
putBucketAclOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.PutBucketAcl(putBucketAclOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the PutBucketAclOptions model with no property values
putBucketAclOptionsModelNew := new(ibmcloudobjectstorages3apiv2.PutBucketAclOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutBucketAcl(putBucketAclOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetObjectAcl(getObjectAclOptions *GetObjectAclOptions) - Operation response error`, func() {
getObjectAclPath := "/testString/testString?acl"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getObjectAclPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for acl query parameter
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke GetObjectAcl with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetObjectAclOptions model
getObjectAclOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectAclOptions)
getObjectAclOptionsModel.Bucket = core.StringPtr("testString")
getObjectAclOptionsModel.Key = core.StringPtr("testString")
getObjectAclOptionsModel.Acl = core.BoolPtr(true)
getObjectAclOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectAcl(getObjectAclOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetObjectAcl(getObjectAclOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetObjectAcl(getObjectAclOptions *GetObjectAclOptions)`, func() {
getObjectAclPath := "/testString/testString?acl"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getObjectAclPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for acl query parameter
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Owner": {"DisplayName": "DisplayName", "ID": "ID"}, "Grants": {}}`)
}))
})
It(`Invoke GetObjectAcl successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the GetObjectAclOptions model
getObjectAclOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectAclOptions)
getObjectAclOptionsModel.Bucket = core.StringPtr("testString")
getObjectAclOptionsModel.Key = core.StringPtr("testString")
getObjectAclOptionsModel.Acl = core.BoolPtr(true)
getObjectAclOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectAclWithContext(ctx, getObjectAclOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectAcl(getObjectAclOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.GetObjectAclWithContext(ctx, getObjectAclOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getObjectAclPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for acl query parameter
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"Owner": {"DisplayName": "DisplayName", "ID": "ID"}, "Grants": {}}`)
}))
})
It(`Invoke GetObjectAcl successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectAcl(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the GetObjectAclOptions model
getObjectAclOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectAclOptions)
getObjectAclOptionsModel.Bucket = core.StringPtr("testString")
getObjectAclOptionsModel.Key = core.StringPtr("testString")
getObjectAclOptionsModel.Acl = core.BoolPtr(true)
getObjectAclOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetObjectAcl(getObjectAclOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke GetObjectAcl with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetObjectAclOptions model
getObjectAclOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectAclOptions)
getObjectAclOptionsModel.Bucket = core.StringPtr("testString")
getObjectAclOptionsModel.Key = core.StringPtr("testString")
getObjectAclOptionsModel.Acl = core.BoolPtr(true)
getObjectAclOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectAcl(getObjectAclOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the GetObjectAclOptions model with no property values
getObjectAclOptionsModelNew := new(ibmcloudobjectstorages3apiv2.GetObjectAclOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetObjectAcl(getObjectAclOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`PutObjectAcl(putObjectAclOptions *PutObjectAclOptions)`, func() {
putObjectAclPath := "/testString/testString?acl"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(putObjectAclPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["X-Amz-Acl"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Acl"][0]).To(Equal(fmt.Sprintf("%v", "private")))
Expect(req.Header["Content-Md5"]).ToNot(BeNil())
Expect(req.Header["Content-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Grant-Full-Control"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Grant-Full-Control"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Grant-Read"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Grant-Read"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Grant-Read-Acp"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Grant-Read-Acp"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Grant-Write"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Grant-Write"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
Expect(req.Header["X-Amz-Grant-Write-Acp"]).ToNot(BeNil())
Expect(req.Header["X-Amz-Grant-Write-Acp"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
// TODO: Add check for acl query parameter
res.WriteHeader(200)
}))
})
It(`Invoke PutObjectAcl successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.PutObjectAcl(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the PutObjectAclOptions model
putObjectAclOptionsModel := new(ibmcloudobjectstorages3apiv2.PutObjectAclOptions)
putObjectAclOptionsModel.Bucket = core.StringPtr("testString")
putObjectAclOptionsModel.Key = core.StringPtr("testString")
putObjectAclOptionsModel.Acl = core.BoolPtr(true)
putObjectAclOptionsModel.Body = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzAcl = core.StringPtr("private")
putObjectAclOptionsModel.ContentMD5 = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzGrantFullControl = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzGrantRead = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzGrantReadAcp = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzGrantWrite = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzGrantWriteAcp = core.StringPtr("testString")
putObjectAclOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutObjectAcl(putObjectAclOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke PutObjectAcl with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the PutObjectAclOptions model
putObjectAclOptionsModel := new(ibmcloudobjectstorages3apiv2.PutObjectAclOptions)
putObjectAclOptionsModel.Bucket = core.StringPtr("testString")
putObjectAclOptionsModel.Key = core.StringPtr("testString")
putObjectAclOptionsModel.Acl = core.BoolPtr(true)
putObjectAclOptionsModel.Body = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzAcl = core.StringPtr("private")
putObjectAclOptionsModel.ContentMD5 = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzGrantFullControl = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzGrantRead = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzGrantReadAcp = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzGrantWrite = core.StringPtr("testString")
putObjectAclOptionsModel.XAmzGrantWriteAcp = core.StringPtr("testString")
putObjectAclOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.PutObjectAcl(putObjectAclOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the PutObjectAclOptions model with no property values
putObjectAclOptionsModelNew := new(ibmcloudobjectstorages3apiv2.PutObjectAclOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutObjectAcl(putObjectAclOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`Service constructor tests`, func() {
It(`Instantiate service client`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
})
It(`Instantiate service client with error: Invalid URL`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
It(`Instantiate service client with error: Invalid Auth`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://ibmcloudobjectstorages3apiv2/api",
Authenticator: &core.BasicAuthenticator{
Username: "",
Password: "",
},
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
})
Describe(`Service constructor tests using external config`, func() {
Context(`Using external config, construct service client instances`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "noauth",
}
It(`Create service client using external config successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url from constructor successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://testService/api",
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url programatically successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("https://testService/api")
Expect(err).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
})
Context(`Using external config, construct service client instances with error: Invalid Auth`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "someOtherAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
Context(`Using external config, construct service client instances with error: Invalid URL`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "NOAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
})
Describe(`Regional endpoint tests`, func() {
It(`GetServiceURLForRegion(region string)`, func() {
var url string
var err error
url, err = ibmcloudobjectstorages3apiv2.GetServiceURLForRegion("INVALID_REGION")
Expect(url).To(BeEmpty())
Expect(err).ToNot(BeNil())
fmt.Fprintf(GinkgoWriter, "Expected error: %s\n", err.Error())
})
})
Describe(`PutObjectTagging(putObjectTaggingOptions *PutObjectTaggingOptions)`, func() {
putObjectTaggingPath := "/testString/testString?tagging"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(putObjectTaggingPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["Content-Md5"]).ToNot(BeNil())
Expect(req.Header["Content-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
// TODO: Add check for tagging query parameter
res.WriteHeader(200)
}))
})
It(`Invoke PutObjectTagging successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.PutObjectTagging(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the PutObjectTaggingOptions model
putObjectTaggingOptionsModel := new(ibmcloudobjectstorages3apiv2.PutObjectTaggingOptions)
putObjectTaggingOptionsModel.Bucket = core.StringPtr("testString")
putObjectTaggingOptionsModel.Key = core.StringPtr("testString")
putObjectTaggingOptionsModel.Tagging = core.BoolPtr(true)
putObjectTaggingOptionsModel.Body = core.StringPtr("testString")
putObjectTaggingOptionsModel.ContentMD5 = core.StringPtr("testString")
putObjectTaggingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutObjectTagging(putObjectTaggingOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke PutObjectTagging with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the PutObjectTaggingOptions model
putObjectTaggingOptionsModel := new(ibmcloudobjectstorages3apiv2.PutObjectTaggingOptions)
putObjectTaggingOptionsModel.Bucket = core.StringPtr("testString")
putObjectTaggingOptionsModel.Key = core.StringPtr("testString")
putObjectTaggingOptionsModel.Tagging = core.BoolPtr(true)
putObjectTaggingOptionsModel.Body = core.StringPtr("testString")
putObjectTaggingOptionsModel.ContentMD5 = core.StringPtr("testString")
putObjectTaggingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.PutObjectTagging(putObjectTaggingOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the PutObjectTaggingOptions model with no property values
putObjectTaggingOptionsModelNew := new(ibmcloudobjectstorages3apiv2.PutObjectTaggingOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutObjectTagging(putObjectTaggingOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetObjectTagging(getObjectTaggingOptions *GetObjectTaggingOptions) - Operation response error`, func() {
getObjectTaggingPath := "/testString/testString?tagging"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getObjectTaggingPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for tagging query parameter
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke GetObjectTagging with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetObjectTaggingOptions model
getObjectTaggingOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectTaggingOptions)
getObjectTaggingOptionsModel.Bucket = core.StringPtr("testString")
getObjectTaggingOptionsModel.Key = core.StringPtr("testString")
getObjectTaggingOptionsModel.Tagging = core.BoolPtr(true)
getObjectTaggingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectTagging(getObjectTaggingOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetObjectTagging(getObjectTaggingOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetObjectTagging(getObjectTaggingOptions *GetObjectTaggingOptions)`, func() {
getObjectTaggingPath := "/testString/testString?tagging"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getObjectTaggingPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for tagging query parameter
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"TagSet": {}}`)
}))
})
It(`Invoke GetObjectTagging successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the GetObjectTaggingOptions model
getObjectTaggingOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectTaggingOptions)
getObjectTaggingOptionsModel.Bucket = core.StringPtr("testString")
getObjectTaggingOptionsModel.Key = core.StringPtr("testString")
getObjectTaggingOptionsModel.Tagging = core.BoolPtr(true)
getObjectTaggingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectTaggingWithContext(ctx, getObjectTaggingOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectTagging(getObjectTaggingOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.GetObjectTaggingWithContext(ctx, getObjectTaggingOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getObjectTaggingPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for tagging query parameter
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"TagSet": {}}`)
}))
})
It(`Invoke GetObjectTagging successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectTagging(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the GetObjectTaggingOptions model
getObjectTaggingOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectTaggingOptions)
getObjectTaggingOptionsModel.Bucket = core.StringPtr("testString")
getObjectTaggingOptionsModel.Key = core.StringPtr("testString")
getObjectTaggingOptionsModel.Tagging = core.BoolPtr(true)
getObjectTaggingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetObjectTagging(getObjectTaggingOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke GetObjectTagging with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetObjectTaggingOptions model
getObjectTaggingOptionsModel := new(ibmcloudobjectstorages3apiv2.GetObjectTaggingOptions)
getObjectTaggingOptionsModel.Bucket = core.StringPtr("testString")
getObjectTaggingOptionsModel.Key = core.StringPtr("testString")
getObjectTaggingOptionsModel.Tagging = core.BoolPtr(true)
getObjectTaggingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetObjectTagging(getObjectTaggingOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the GetObjectTaggingOptions model with no property values
getObjectTaggingOptionsModelNew := new(ibmcloudobjectstorages3apiv2.GetObjectTaggingOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetObjectTagging(getObjectTaggingOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`DeleteObjectTagging(deleteObjectTaggingOptions *DeleteObjectTaggingOptions)`, func() {
deleteObjectTaggingPath := "/testString/testString?tagging"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(deleteObjectTaggingPath))
Expect(req.Method).To(Equal("DELETE"))
// TODO: Add check for tagging query parameter
res.WriteHeader(204)
}))
})
It(`Invoke DeleteObjectTagging successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteObjectTagging(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the DeleteObjectTaggingOptions model
deleteObjectTaggingOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteObjectTaggingOptions)
deleteObjectTaggingOptionsModel.Bucket = core.StringPtr("testString")
deleteObjectTaggingOptionsModel.Key = core.StringPtr("testString")
deleteObjectTaggingOptionsModel.Tagging = core.BoolPtr(true)
deleteObjectTaggingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteObjectTagging(deleteObjectTaggingOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke DeleteObjectTagging with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the DeleteObjectTaggingOptions model
deleteObjectTaggingOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteObjectTaggingOptions)
deleteObjectTaggingOptionsModel.Bucket = core.StringPtr("testString")
deleteObjectTaggingOptionsModel.Key = core.StringPtr("testString")
deleteObjectTaggingOptionsModel.Tagging = core.BoolPtr(true)
deleteObjectTaggingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteObjectTagging(deleteObjectTaggingOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the DeleteObjectTaggingOptions model with no property values
deleteObjectTaggingOptionsModelNew := new(ibmcloudobjectstorages3apiv2.DeleteObjectTaggingOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteObjectTagging(deleteObjectTaggingOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`Service constructor tests`, func() {
It(`Instantiate service client`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
})
It(`Instantiate service client with error: Invalid URL`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
It(`Instantiate service client with error: Invalid Auth`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://ibmcloudobjectstorages3apiv2/api",
Authenticator: &core.BasicAuthenticator{
Username: "",
Password: "",
},
})
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
})
})
Describe(`Service constructor tests using external config`, func() {
Context(`Using external config, construct service client instances`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "noauth",
}
It(`Create service client using external config successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url from constructor successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "https://testService/api",
})
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
It(`Create service client using external config and set url programatically successfully`, func() {
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("https://testService/api")
Expect(err).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService.Service.GetServiceURL()).To(Equal("https://testService/api"))
ClearTestEnvironment(testEnvironment)
clone := ibmCloudObjectStorageS3ApiService.Clone()
Expect(clone).ToNot(BeNil())
Expect(clone.Service != ibmCloudObjectStorageS3ApiService.Service).To(BeTrue())
Expect(clone.GetServiceURL()).To(Equal(ibmCloudObjectStorageS3ApiService.GetServiceURL()))
Expect(clone.Service.Options.Authenticator).To(Equal(ibmCloudObjectStorageS3ApiService.Service.Options.Authenticator))
})
})
Context(`Using external config, construct service client instances with error: Invalid Auth`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_URL": "https://ibmcloudobjectstorages3apiv2/api",
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "someOtherAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
Context(`Using external config, construct service client instances with error: Invalid URL`, func() {
// Map containing environment variables used in testing.
var testEnvironment = map[string]string{
"IBM_CLOUD_OBJECT_STORAGE_S3_API_AUTH_TYPE": "NOAuth",
}
SetTestEnvironment(testEnvironment)
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2UsingExternalConfig(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "{BAD_URL_STRING",
})
It(`Instantiate service client with error`, func() {
Expect(ibmCloudObjectStorageS3ApiService).To(BeNil())
Expect(serviceErr).ToNot(BeNil())
ClearTestEnvironment(testEnvironment)
})
})
})
Describe(`Regional endpoint tests`, func() {
It(`GetServiceURLForRegion(region string)`, func() {
var url string
var err error
url, err = ibmcloudobjectstorages3apiv2.GetServiceURLForRegion("INVALID_REGION")
Expect(url).To(BeEmpty())
Expect(err).ToNot(BeNil())
fmt.Fprintf(GinkgoWriter, "Expected error: %s\n", err.Error())
})
})
Describe(`PutBucketWebsite(putBucketWebsiteOptions *PutBucketWebsiteOptions)`, func() {
putBucketWebsitePath := "/testString?website"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(putBucketWebsitePath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["Content-Md5"]).ToNot(BeNil())
Expect(req.Header["Content-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
// TODO: Add check for website query parameter
res.WriteHeader(200)
}))
})
It(`Invoke PutBucketWebsite successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.PutBucketWebsite(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the PutBucketWebsiteOptions model
putBucketWebsiteOptionsModel := new(ibmcloudobjectstorages3apiv2.PutBucketWebsiteOptions)
putBucketWebsiteOptionsModel.Bucket = core.StringPtr("testString")
putBucketWebsiteOptionsModel.Website = core.BoolPtr(true)
putBucketWebsiteOptionsModel.Body = core.StringPtr("testString")
putBucketWebsiteOptionsModel.ContentMD5 = core.StringPtr("testString")
putBucketWebsiteOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutBucketWebsite(putBucketWebsiteOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke PutBucketWebsite with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the PutBucketWebsiteOptions model
putBucketWebsiteOptionsModel := new(ibmcloudobjectstorages3apiv2.PutBucketWebsiteOptions)
putBucketWebsiteOptionsModel.Bucket = core.StringPtr("testString")
putBucketWebsiteOptionsModel.Website = core.BoolPtr(true)
putBucketWebsiteOptionsModel.Body = core.StringPtr("testString")
putBucketWebsiteOptionsModel.ContentMD5 = core.StringPtr("testString")
putBucketWebsiteOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.PutBucketWebsite(putBucketWebsiteOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the PutBucketWebsiteOptions model with no property values
putBucketWebsiteOptionsModelNew := new(ibmcloudobjectstorages3apiv2.PutBucketWebsiteOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutBucketWebsite(putBucketWebsiteOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetBucketWebsite(getBucketWebsiteOptions *GetBucketWebsiteOptions) - Operation response error`, func() {
getBucketWebsitePath := "/testString?website"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getBucketWebsitePath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for website query parameter
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke GetBucketWebsite with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetBucketWebsiteOptions model
getBucketWebsiteOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketWebsiteOptions)
getBucketWebsiteOptionsModel.Bucket = core.StringPtr("testString")
getBucketWebsiteOptionsModel.Website = core.BoolPtr(true)
getBucketWebsiteOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketWebsite(getBucketWebsiteOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketWebsite(getBucketWebsiteOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetBucketWebsite(getBucketWebsiteOptions *GetBucketWebsiteOptions)`, func() {
getBucketWebsitePath := "/testString?website"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getBucketWebsitePath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for website query parameter
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"RedirectAllRequestsTo": {"HostName": "HostName", "Protocol": "http"}, "IndexDocument": {"Suffix": "Suffix"}, "ErrorDocument": {"Key": "Key"}, "RoutingRules": {}}`)
}))
})
It(`Invoke GetBucketWebsite successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the GetBucketWebsiteOptions model
getBucketWebsiteOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketWebsiteOptions)
getBucketWebsiteOptionsModel.Bucket = core.StringPtr("testString")
getBucketWebsiteOptionsModel.Website = core.BoolPtr(true)
getBucketWebsiteOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketWebsiteWithContext(ctx, getBucketWebsiteOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketWebsite(getBucketWebsiteOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketWebsiteWithContext(ctx, getBucketWebsiteOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getBucketWebsitePath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for website query parameter
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"RedirectAllRequestsTo": {"HostName": "HostName", "Protocol": "http"}, "IndexDocument": {"Suffix": "Suffix"}, "ErrorDocument": {"Key": "Key"}, "RoutingRules": {}}`)
}))
})
It(`Invoke GetBucketWebsite successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketWebsite(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the GetBucketWebsiteOptions model
getBucketWebsiteOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketWebsiteOptions)
getBucketWebsiteOptionsModel.Bucket = core.StringPtr("testString")
getBucketWebsiteOptionsModel.Website = core.BoolPtr(true)
getBucketWebsiteOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketWebsite(getBucketWebsiteOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke GetBucketWebsite with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetBucketWebsiteOptions model
getBucketWebsiteOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketWebsiteOptions)
getBucketWebsiteOptionsModel.Bucket = core.StringPtr("testString")
getBucketWebsiteOptionsModel.Website = core.BoolPtr(true)
getBucketWebsiteOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketWebsite(getBucketWebsiteOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the GetBucketWebsiteOptions model with no property values
getBucketWebsiteOptionsModelNew := new(ibmcloudobjectstorages3apiv2.GetBucketWebsiteOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketWebsite(getBucketWebsiteOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`DeleteBucketWebsite(deleteBucketWebsiteOptions *DeleteBucketWebsiteOptions)`, func() {
deleteBucketWebsitePath := "/testString?website"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(deleteBucketWebsitePath))
Expect(req.Method).To(Equal("DELETE"))
// TODO: Add check for website query parameter
res.WriteHeader(204)
}))
})
It(`Invoke DeleteBucketWebsite successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteBucketWebsite(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the DeleteBucketWebsiteOptions model
deleteBucketWebsiteOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteBucketWebsiteOptions)
deleteBucketWebsiteOptionsModel.Bucket = core.StringPtr("testString")
deleteBucketWebsiteOptionsModel.Website = core.BoolPtr(true)
deleteBucketWebsiteOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteBucketWebsite(deleteBucketWebsiteOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke DeleteBucketWebsite with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the DeleteBucketWebsiteOptions model
deleteBucketWebsiteOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteBucketWebsiteOptions)
deleteBucketWebsiteOptionsModel.Bucket = core.StringPtr("testString")
deleteBucketWebsiteOptionsModel.Website = core.BoolPtr(true)
deleteBucketWebsiteOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteBucketWebsite(deleteBucketWebsiteOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the DeleteBucketWebsiteOptions model with no property values
deleteBucketWebsiteOptionsModelNew := new(ibmcloudobjectstorages3apiv2.DeleteBucketWebsiteOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteBucketWebsite(deleteBucketWebsiteOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`PutBucketCors(putBucketCorsOptions *PutBucketCorsOptions)`, func() {
putBucketCorsPath := "/testString?cors"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(putBucketCorsPath))
Expect(req.Method).To(Equal("PUT"))
// For gzip-disabled operation, verify Content-Encoding is not set.
Expect(req.Header.Get("Content-Encoding")).To(BeEmpty())
// If there is a body, then make sure we can read it
bodyBuf := new(bytes.Buffer)
if req.Header.Get("Content-Encoding") == "gzip" {
body, err := core.NewGzipDecompressionReader(req.Body)
Expect(err).To(BeNil())
_, err = bodyBuf.ReadFrom(body)
Expect(err).To(BeNil())
} else {
_, err := bodyBuf.ReadFrom(req.Body)
Expect(err).To(BeNil())
}
fmt.Fprintf(GinkgoWriter, " Request body: %s", bodyBuf.String())
Expect(req.Header["Content-Md5"]).ToNot(BeNil())
Expect(req.Header["Content-Md5"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
// TODO: Add check for cors query parameter
res.WriteHeader(200)
}))
})
It(`Invoke PutBucketCors successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.PutBucketCors(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the PutBucketCorsOptions model
putBucketCorsOptionsModel := new(ibmcloudobjectstorages3apiv2.PutBucketCorsOptions)
putBucketCorsOptionsModel.Bucket = core.StringPtr("testString")
putBucketCorsOptionsModel.Cors = core.BoolPtr(true)
putBucketCorsOptionsModel.Body = core.StringPtr("testString")
putBucketCorsOptionsModel.ContentMD5 = core.StringPtr("testString")
putBucketCorsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutBucketCors(putBucketCorsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke PutBucketCors with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the PutBucketCorsOptions model
putBucketCorsOptionsModel := new(ibmcloudobjectstorages3apiv2.PutBucketCorsOptions)
putBucketCorsOptionsModel.Bucket = core.StringPtr("testString")
putBucketCorsOptionsModel.Cors = core.BoolPtr(true)
putBucketCorsOptionsModel.Body = core.StringPtr("testString")
putBucketCorsOptionsModel.ContentMD5 = core.StringPtr("testString")
putBucketCorsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.PutBucketCors(putBucketCorsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the PutBucketCorsOptions model with no property values
putBucketCorsOptionsModelNew := new(ibmcloudobjectstorages3apiv2.PutBucketCorsOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.PutBucketCors(putBucketCorsOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetBucketCors(getBucketCorsOptions *GetBucketCorsOptions) - Operation response error`, func() {
getBucketCorsPath := "/testString?cors"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getBucketCorsPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for cors query parameter
res.Header().Set("Content-type", "application/json")
res.WriteHeader(200)
fmt.Fprintf(res, `} this is not valid json {`)
}))
})
It(`Invoke GetBucketCors with error: Operation response processing error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetBucketCorsOptions model
getBucketCorsOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketCorsOptions)
getBucketCorsOptionsModel.Bucket = core.StringPtr("testString")
getBucketCorsOptionsModel.Cors = core.BoolPtr(true)
getBucketCorsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Expect response parsing to fail since we are receiving a text/plain response
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketCors(getBucketCorsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
// Enable retries and test again
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketCors(getBucketCorsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`GetBucketCors(getBucketCorsOptions *GetBucketCorsOptions)`, func() {
getBucketCorsPath := "/testString?cors"
Context(`Using mock server endpoint with timeout`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getBucketCorsPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for cors query parameter
// Sleep a short time to support a timeout test
time.Sleep(100 * time.Millisecond)
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"CORSRules": {}}`)
}))
})
It(`Invoke GetBucketCors successfully with retries`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
ibmCloudObjectStorageS3ApiService.EnableRetries(0, 0)
// Construct an instance of the GetBucketCorsOptions model
getBucketCorsOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketCorsOptions)
getBucketCorsOptionsModel.Bucket = core.StringPtr("testString")
getBucketCorsOptionsModel.Cors = core.BoolPtr(true)
getBucketCorsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with a Context to test a timeout error
ctx, cancelFunc := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc()
_, _, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketCorsWithContext(ctx, getBucketCorsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
// Disable retries and test again
ibmCloudObjectStorageS3ApiService.DisableRetries()
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketCors(getBucketCorsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
// Re-test the timeout error with retries disabled
ctx, cancelFunc2 := context.WithTimeout(context.Background(), 80*time.Millisecond)
defer cancelFunc2()
_, _, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketCorsWithContext(ctx, getBucketCorsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring("deadline exceeded"))
})
AfterEach(func() {
testServer.Close()
})
})
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(getBucketCorsPath))
Expect(req.Method).To(Equal("GET"))
// TODO: Add check for cors query parameter
// Set mock response
res.Header().Set("Content-type", "text/xml")
res.WriteHeader(200)
fmt.Fprintf(res, "%s", `{"CORSRules": {}}`)
}))
})
It(`Invoke GetBucketCors successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketCors(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct an instance of the GetBucketCorsOptions model
getBucketCorsOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketCorsOptions)
getBucketCorsOptionsModel.Bucket = core.StringPtr("testString")
getBucketCorsOptionsModel.Cors = core.BoolPtr(true)
getBucketCorsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketCors(getBucketCorsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
Expect(result).ToNot(BeNil())
})
It(`Invoke GetBucketCors with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the GetBucketCorsOptions model
getBucketCorsOptionsModel := new(ibmcloudobjectstorages3apiv2.GetBucketCorsOptions)
getBucketCorsOptionsModel.Bucket = core.StringPtr("testString")
getBucketCorsOptionsModel.Cors = core.BoolPtr(true)
getBucketCorsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
result, response, operationErr := ibmCloudObjectStorageS3ApiService.GetBucketCors(getBucketCorsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
Expect(result).To(BeNil())
// Construct a second instance of the GetBucketCorsOptions model with no property values
getBucketCorsOptionsModelNew := new(ibmcloudobjectstorages3apiv2.GetBucketCorsOptions)
// Invoke operation with invalid model (negative test)
result, response, operationErr = ibmCloudObjectStorageS3ApiService.GetBucketCors(getBucketCorsOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
Expect(result).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`DeleteBucketCors(deleteBucketCorsOptions *DeleteBucketCorsOptions)`, func() {
deleteBucketCorsPath := "/testString?cors"
Context(`Using mock server endpoint`, func() {
BeforeEach(func() {
testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
// Verify the contents of the request
Expect(req.URL.EscapedPath()).To(Equal(deleteBucketCorsPath))
Expect(req.Method).To(Equal("DELETE"))
// TODO: Add check for cors query parameter
res.WriteHeader(204)
}))
})
It(`Invoke DeleteBucketCors successfully`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Invoke operation with nil options model (negative test)
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteBucketCors(nil)
Expect(operationErr).NotTo(BeNil())
Expect(response).To(BeNil())
// Construct an instance of the DeleteBucketCorsOptions model
deleteBucketCorsOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteBucketCorsOptions)
deleteBucketCorsOptionsModel.Bucket = core.StringPtr("testString")
deleteBucketCorsOptionsModel.Cors = core.BoolPtr(true)
deleteBucketCorsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with valid options model (positive test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteBucketCors(deleteBucketCorsOptionsModel)
Expect(operationErr).To(BeNil())
Expect(response).ToNot(BeNil())
})
It(`Invoke DeleteBucketCors with error: Operation validation and request error`, func() {
ibmCloudObjectStorageS3ApiService, serviceErr := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: testServer.URL,
Authenticator: &core.NoAuthAuthenticator{},
})
Expect(serviceErr).To(BeNil())
Expect(ibmCloudObjectStorageS3ApiService).ToNot(BeNil())
// Construct an instance of the DeleteBucketCorsOptions model
deleteBucketCorsOptionsModel := new(ibmcloudobjectstorages3apiv2.DeleteBucketCorsOptions)
deleteBucketCorsOptionsModel.Bucket = core.StringPtr("testString")
deleteBucketCorsOptionsModel.Cors = core.BoolPtr(true)
deleteBucketCorsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
// Invoke operation with empty URL (negative test)
err := ibmCloudObjectStorageS3ApiService.SetServiceURL("")
Expect(err).To(BeNil())
response, operationErr := ibmCloudObjectStorageS3ApiService.DeleteBucketCors(deleteBucketCorsOptionsModel)
Expect(operationErr).ToNot(BeNil())
Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
Expect(response).To(BeNil())
// Construct a second instance of the DeleteBucketCorsOptions model with no property values
deleteBucketCorsOptionsModelNew := new(ibmcloudobjectstorages3apiv2.DeleteBucketCorsOptions)
// Invoke operation with invalid model (negative test)
response, operationErr = ibmCloudObjectStorageS3ApiService.DeleteBucketCors(deleteBucketCorsOptionsModelNew)
Expect(operationErr).ToNot(BeNil())
Expect(response).To(BeNil())
})
AfterEach(func() {
testServer.Close()
})
})
})
Describe(`Model constructor tests`, func() {
Context(`Using a service client instance`, func() {
ibmCloudObjectStorageS3ApiService, _ := ibmcloudobjectstorages3apiv2.NewIbmCloudObjectStorageS3ApiV2(&ibmcloudobjectstorages3apiv2.IbmCloudObjectStorageS3ApiV2Options{
URL: "http://ibmcloudobjectstorages3apiv2modelgenerator.com",
Authenticator: &core.NoAuthAuthenticator{},
})
It(`Invoke NewAbortMultipartUploadOptions successfully`, func() {
// Construct an instance of the AbortMultipartUploadOptions model
bucket := "testString"
key := "testString"
uploadID := "testString"
abortMultipartUploadOptionsModel := ibmCloudObjectStorageS3ApiService.NewAbortMultipartUploadOptions(bucket, key, uploadID)
abortMultipartUploadOptionsModel.SetBucket("testString")
abortMultipartUploadOptionsModel.SetKey("testString")
abortMultipartUploadOptionsModel.SetUploadID("testString")
abortMultipartUploadOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(abortMultipartUploadOptionsModel).ToNot(BeNil())
Expect(abortMultipartUploadOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(abortMultipartUploadOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(abortMultipartUploadOptionsModel.UploadID).To(Equal(core.StringPtr("testString")))
Expect(abortMultipartUploadOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewCompleteMultipartUploadOptions successfully`, func() {
// Construct an instance of the CompleteMultipartUploadOptions model
bucket := "testString"
key := "testString"
uploadID := "testString"
body := "testString"
completeMultipartUploadOptionsModel := ibmCloudObjectStorageS3ApiService.NewCompleteMultipartUploadOptions(bucket, key, uploadID, body)
completeMultipartUploadOptionsModel.SetBucket("testString")
completeMultipartUploadOptionsModel.SetKey("testString")
completeMultipartUploadOptionsModel.SetUploadID("testString")
completeMultipartUploadOptionsModel.SetBody("testString")
completeMultipartUploadOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(completeMultipartUploadOptionsModel).ToNot(BeNil())
Expect(completeMultipartUploadOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(completeMultipartUploadOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(completeMultipartUploadOptionsModel.UploadID).To(Equal(core.StringPtr("testString")))
Expect(completeMultipartUploadOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(completeMultipartUploadOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewCopyObjectOptions successfully`, func() {
// Construct an instance of the CopyObjectOptions model
bucket := "testString"
xAmzCopySource := "testString"
targetKey := "testString"
body := "testString"
copyObjectOptionsModel := ibmCloudObjectStorageS3ApiService.NewCopyObjectOptions(bucket, xAmzCopySource, targetKey, body)
copyObjectOptionsModel.SetBucket("testString")
copyObjectOptionsModel.SetXAmzCopySource("testString")
copyObjectOptionsModel.SetTargetKey("testString")
copyObjectOptionsModel.SetBody("testString")
copyObjectOptionsModel.SetXAmzAcl("private")
copyObjectOptionsModel.SetCacheControl("testString")
copyObjectOptionsModel.SetContentDisposition("testString")
copyObjectOptionsModel.SetContentEncoding("testString")
copyObjectOptionsModel.SetContentLanguage("testString")
copyObjectOptionsModel.SetXAmzCopySourceIfMatch("testString")
copyObjectOptionsModel.SetXAmzCopySourceIfModifiedSince(CreateMockDateTime())
copyObjectOptionsModel.SetXAmzCopySourceIfNoneMatch("testString")
copyObjectOptionsModel.SetXAmzCopySourceIfUnmodifiedSince(CreateMockDateTime())
copyObjectOptionsModel.SetExpires(CreateMockDateTime())
copyObjectOptionsModel.SetXAmzMetadataDirective("COPY")
copyObjectOptionsModel.SetXAmzTaggingDirective("COPY")
copyObjectOptionsModel.SetXAmzServerSideEncryption("AES256")
copyObjectOptionsModel.SetXAmzWebsiteRedirectLocation("testString")
copyObjectOptionsModel.SetXAmzServerSideEncryptionCustomerAlgorithm("testString")
copyObjectOptionsModel.SetXAmzServerSideEncryptionCustomerKey("testString")
copyObjectOptionsModel.SetXAmzServerSideEncryptionCustomerKeyMD5("testString")
copyObjectOptionsModel.SetXAmzCopySourceServerSideEncryptionCustomerAlgorithm("testString")
copyObjectOptionsModel.SetXAmzCopySourceServerSideEncryptionCustomerKey("testString")
copyObjectOptionsModel.SetXAmzCopySourceServerSideEncryptionCustomerKeyMD5("testString")
copyObjectOptionsModel.SetXAmzTagging("testString")
copyObjectOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(copyObjectOptionsModel).ToNot(BeNil())
Expect(copyObjectOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzCopySource).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.TargetKey).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzAcl).To(Equal(core.StringPtr("private")))
Expect(copyObjectOptionsModel.CacheControl).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.ContentDisposition).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.ContentEncoding).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.ContentLanguage).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzCopySourceIfMatch).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzCopySourceIfModifiedSince).To(Equal(CreateMockDateTime()))
Expect(copyObjectOptionsModel.XAmzCopySourceIfNoneMatch).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzCopySourceIfUnmodifiedSince).To(Equal(CreateMockDateTime()))
Expect(copyObjectOptionsModel.Expires).To(Equal(CreateMockDateTime()))
Expect(copyObjectOptionsModel.XAmzMetadataDirective).To(Equal(core.StringPtr("COPY")))
Expect(copyObjectOptionsModel.XAmzTaggingDirective).To(Equal(core.StringPtr("COPY")))
Expect(copyObjectOptionsModel.XAmzServerSideEncryption).To(Equal(core.StringPtr("AES256")))
Expect(copyObjectOptionsModel.XAmzWebsiteRedirectLocation).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzServerSideEncryptionCustomerKey).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerAlgorithm).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKey).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKeyMD5).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.XAmzTagging).To(Equal(core.StringPtr("testString")))
Expect(copyObjectOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewCreateBucketOptions successfully`, func() {
// Construct an instance of the CreateBucketOptions model
bucket := "my-new-bucket"
ibmServiceInstanceID := "d6f76k03-6k4f-4a82-n165-697654o63903"
createBucketOptionsModel := ibmCloudObjectStorageS3ApiService.NewCreateBucketOptions(bucket, ibmServiceInstanceID)
createBucketOptionsModel.SetBucket("my-new-bucket")
createBucketOptionsModel.SetIbmServiceInstanceID("d6f76k03-6k4f-4a82-n165-697654o63903")
createBucketOptionsModel.SetBody("testString")
createBucketOptionsModel.SetIbmSseKpEncryptionAlgorithm("AES256")
createBucketOptionsModel.SetIbmSseKpCustomerRootKeyCrn("crn:v1:bluemix:public:kms:us-south:a/f047b55a3362ac06afad8a3f2f5586ea:12e8c9c2-a162-472d-b7d6-8b9a86b815a6:key:02fd6835-6001-4482-a892-13bd2085f75d")
createBucketOptionsModel.SetXAmzAcl("private")
createBucketOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(createBucketOptionsModel).ToNot(BeNil())
Expect(createBucketOptionsModel.Bucket).To(Equal(core.StringPtr("my-new-bucket")))
Expect(createBucketOptionsModel.IbmServiceInstanceID).To(Equal(core.StringPtr("d6f76k03-6k4f-4a82-n165-697654o63903")))
Expect(createBucketOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(createBucketOptionsModel.IbmSseKpEncryptionAlgorithm).To(Equal(core.StringPtr("AES256")))
Expect(createBucketOptionsModel.IbmSseKpCustomerRootKeyCrn).To(Equal(core.StringPtr("crn:v1:bluemix:public:kms:us-south:a/f047b55a3362ac06afad8a3f2f5586ea:12e8c9c2-a162-472d-b7d6-8b9a86b815a6:key:02fd6835-6001-4482-a892-13bd2085f75d")))
Expect(createBucketOptionsModel.XAmzAcl).To(Equal(core.StringPtr("private")))
Expect(createBucketOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewDeleteBucketCorsOptions successfully`, func() {
// Construct an instance of the DeleteBucketCorsOptions model
bucket := "testString"
cors := true
deleteBucketCorsOptionsModel := ibmCloudObjectStorageS3ApiService.NewDeleteBucketCorsOptions(bucket, cors)
deleteBucketCorsOptionsModel.SetBucket("testString")
deleteBucketCorsOptionsModel.SetCors(true)
deleteBucketCorsOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(deleteBucketCorsOptionsModel).ToNot(BeNil())
Expect(deleteBucketCorsOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(deleteBucketCorsOptionsModel.Cors).To(Equal(core.BoolPtr(true)))
Expect(deleteBucketCorsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewDeleteBucketLifecycleOptions successfully`, func() {
// Construct an instance of the DeleteBucketLifecycleOptions model
bucket := "testString"
lifecycle := true
deleteBucketLifecycleOptionsModel := ibmCloudObjectStorageS3ApiService.NewDeleteBucketLifecycleOptions(bucket, lifecycle)
deleteBucketLifecycleOptionsModel.SetBucket("testString")
deleteBucketLifecycleOptionsModel.SetLifecycle(true)
deleteBucketLifecycleOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(deleteBucketLifecycleOptionsModel).ToNot(BeNil())
Expect(deleteBucketLifecycleOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(deleteBucketLifecycleOptionsModel.Lifecycle).To(Equal(core.BoolPtr(true)))
Expect(deleteBucketLifecycleOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewDeleteBucketOptions successfully`, func() {
// Construct an instance of the DeleteBucketOptions model
bucket := "testString"
deleteBucketOptionsModel := ibmCloudObjectStorageS3ApiService.NewDeleteBucketOptions(bucket)
deleteBucketOptionsModel.SetBucket("testString")
deleteBucketOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(deleteBucketOptionsModel).ToNot(BeNil())
Expect(deleteBucketOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(deleteBucketOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewDeleteBucketWebsiteOptions successfully`, func() {
// Construct an instance of the DeleteBucketWebsiteOptions model
bucket := "testString"
website := true
deleteBucketWebsiteOptionsModel := ibmCloudObjectStorageS3ApiService.NewDeleteBucketWebsiteOptions(bucket, website)
deleteBucketWebsiteOptionsModel.SetBucket("testString")
deleteBucketWebsiteOptionsModel.SetWebsite(true)
deleteBucketWebsiteOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(deleteBucketWebsiteOptionsModel).ToNot(BeNil())
Expect(deleteBucketWebsiteOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(deleteBucketWebsiteOptionsModel.Website).To(Equal(core.BoolPtr(true)))
Expect(deleteBucketWebsiteOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewDeleteObjectOptions successfully`, func() {
// Construct an instance of the DeleteObjectOptions model
bucket := "testString"
key := "testString"
deleteObjectOptionsModel := ibmCloudObjectStorageS3ApiService.NewDeleteObjectOptions(bucket, key)
deleteObjectOptionsModel.SetBucket("testString")
deleteObjectOptionsModel.SetKey("testString")
deleteObjectOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(deleteObjectOptionsModel).ToNot(BeNil())
Expect(deleteObjectOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(deleteObjectOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(deleteObjectOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewDeleteObjectTaggingOptions successfully`, func() {
// Construct an instance of the DeleteObjectTaggingOptions model
bucket := "testString"
key := "testString"
tagging := true
deleteObjectTaggingOptionsModel := ibmCloudObjectStorageS3ApiService.NewDeleteObjectTaggingOptions(bucket, key, tagging)
deleteObjectTaggingOptionsModel.SetBucket("testString")
deleteObjectTaggingOptionsModel.SetKey("testString")
deleteObjectTaggingOptionsModel.SetTagging(true)
deleteObjectTaggingOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(deleteObjectTaggingOptionsModel).ToNot(BeNil())
Expect(deleteObjectTaggingOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(deleteObjectTaggingOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(deleteObjectTaggingOptionsModel.Tagging).To(Equal(core.BoolPtr(true)))
Expect(deleteObjectTaggingOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewDeleteObjectsOptions successfully`, func() {
// Construct an instance of the DeleteObjectsOptions model
bucket := "testString"
deleteVar := true
body := "testString"
deleteObjectsOptionsModel := ibmCloudObjectStorageS3ApiService.NewDeleteObjectsOptions(bucket, deleteVar, body)
deleteObjectsOptionsModel.SetBucket("testString")
deleteObjectsOptionsModel.SetDelete(true)
deleteObjectsOptionsModel.SetBody("testString")
deleteObjectsOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(deleteObjectsOptionsModel).ToNot(BeNil())
Expect(deleteObjectsOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(deleteObjectsOptionsModel.Delete).To(Equal(core.BoolPtr(true)))
Expect(deleteObjectsOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(deleteObjectsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewDeletePublicAccessBlockOptions successfully`, func() {
// Construct an instance of the DeletePublicAccessBlockOptions model
bucket := "testString"
publicAccessBlock := true
deletePublicAccessBlockOptionsModel := ibmCloudObjectStorageS3ApiService.NewDeletePublicAccessBlockOptions(bucket, publicAccessBlock)
deletePublicAccessBlockOptionsModel.SetBucket("testString")
deletePublicAccessBlockOptionsModel.SetPublicAccessBlock(true)
deletePublicAccessBlockOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(deletePublicAccessBlockOptionsModel).ToNot(BeNil())
Expect(deletePublicAccessBlockOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(deletePublicAccessBlockOptionsModel.PublicAccessBlock).To(Equal(core.BoolPtr(true)))
Expect(deletePublicAccessBlockOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewGetBucketAclOptions successfully`, func() {
// Construct an instance of the GetBucketAclOptions model
bucket := "testString"
acl := true
getBucketAclOptionsModel := ibmCloudObjectStorageS3ApiService.NewGetBucketAclOptions(bucket, acl)
getBucketAclOptionsModel.SetBucket("testString")
getBucketAclOptionsModel.SetAcl(true)
getBucketAclOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(getBucketAclOptionsModel).ToNot(BeNil())
Expect(getBucketAclOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(getBucketAclOptionsModel.Acl).To(Equal(core.BoolPtr(true)))
Expect(getBucketAclOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewGetBucketCorsOptions successfully`, func() {
// Construct an instance of the GetBucketCorsOptions model
bucket := "testString"
cors := true
getBucketCorsOptionsModel := ibmCloudObjectStorageS3ApiService.NewGetBucketCorsOptions(bucket, cors)
getBucketCorsOptionsModel.SetBucket("testString")
getBucketCorsOptionsModel.SetCors(true)
getBucketCorsOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(getBucketCorsOptionsModel).ToNot(BeNil())
Expect(getBucketCorsOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(getBucketCorsOptionsModel.Cors).To(Equal(core.BoolPtr(true)))
Expect(getBucketCorsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewGetBucketLifecycleConfigurationOptions successfully`, func() {
// Construct an instance of the GetBucketLifecycleConfigurationOptions model
bucket := "testString"
lifecycle := true
getBucketLifecycleConfigurationOptionsModel := ibmCloudObjectStorageS3ApiService.NewGetBucketLifecycleConfigurationOptions(bucket, lifecycle)
getBucketLifecycleConfigurationOptionsModel.SetBucket("testString")
getBucketLifecycleConfigurationOptionsModel.SetLifecycle(true)
getBucketLifecycleConfigurationOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(getBucketLifecycleConfigurationOptionsModel).ToNot(BeNil())
Expect(getBucketLifecycleConfigurationOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(getBucketLifecycleConfigurationOptionsModel.Lifecycle).To(Equal(core.BoolPtr(true)))
Expect(getBucketLifecycleConfigurationOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewGetBucketWebsiteOptions successfully`, func() {
// Construct an instance of the GetBucketWebsiteOptions model
bucket := "testString"
website := true
getBucketWebsiteOptionsModel := ibmCloudObjectStorageS3ApiService.NewGetBucketWebsiteOptions(bucket, website)
getBucketWebsiteOptionsModel.SetBucket("testString")
getBucketWebsiteOptionsModel.SetWebsite(true)
getBucketWebsiteOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(getBucketWebsiteOptionsModel).ToNot(BeNil())
Expect(getBucketWebsiteOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(getBucketWebsiteOptionsModel.Website).To(Equal(core.BoolPtr(true)))
Expect(getBucketWebsiteOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewGetObjectAclOptions successfully`, func() {
// Construct an instance of the GetObjectAclOptions model
bucket := "testString"
key := "testString"
acl := true
getObjectAclOptionsModel := ibmCloudObjectStorageS3ApiService.NewGetObjectAclOptions(bucket, key, acl)
getObjectAclOptionsModel.SetBucket("testString")
getObjectAclOptionsModel.SetKey("testString")
getObjectAclOptionsModel.SetAcl(true)
getObjectAclOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(getObjectAclOptionsModel).ToNot(BeNil())
Expect(getObjectAclOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(getObjectAclOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(getObjectAclOptionsModel.Acl).To(Equal(core.BoolPtr(true)))
Expect(getObjectAclOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewGetObjectOptions successfully`, func() {
// Construct an instance of the GetObjectOptions model
bucket := "testString"
key := "testString"
getObjectOptionsModel := ibmCloudObjectStorageS3ApiService.NewGetObjectOptions(bucket, key)
getObjectOptionsModel.SetBucket("testString")
getObjectOptionsModel.SetKey("testString")
getObjectOptionsModel.SetIfMatch("testString")
getObjectOptionsModel.SetIfModifiedSince(CreateMockDateTime())
getObjectOptionsModel.SetIfNoneMatch("testString")
getObjectOptionsModel.SetIfUnmodifiedSince(CreateMockDateTime())
getObjectOptionsModel.SetRange("testString")
getObjectOptionsModel.SetResponseCacheControl("testString")
getObjectOptionsModel.SetResponseContentDisposition("testString")
getObjectOptionsModel.SetResponseContentEncoding("testString")
getObjectOptionsModel.SetResponseContentLanguage("testString")
getObjectOptionsModel.SetResponseContentType("testString")
getObjectOptionsModel.SetResponseExpires(CreateMockDateTime())
getObjectOptionsModel.SetXAmzServerSideEncryptionCustomerAlgorithm("testString")
getObjectOptionsModel.SetXAmzServerSideEncryptionCustomerKey("testString")
getObjectOptionsModel.SetXAmzServerSideEncryptionCustomerKeyMD5("testString")
getObjectOptionsModel.SetPartNumber(int64(38))
getObjectOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(getObjectOptionsModel).ToNot(BeNil())
Expect(getObjectOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.IfMatch).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.IfModifiedSince).To(Equal(CreateMockDateTime()))
Expect(getObjectOptionsModel.IfNoneMatch).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.IfUnmodifiedSince).To(Equal(CreateMockDateTime()))
Expect(getObjectOptionsModel.Range).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.ResponseCacheControl).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.ResponseContentDisposition).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.ResponseContentEncoding).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.ResponseContentLanguage).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.ResponseContentType).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.ResponseExpires).To(Equal(CreateMockDateTime()))
Expect(getObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.XAmzServerSideEncryptionCustomerKey).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5).To(Equal(core.StringPtr("testString")))
Expect(getObjectOptionsModel.PartNumber).To(Equal(core.Int64Ptr(int64(38))))
Expect(getObjectOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewGetObjectTaggingOptions successfully`, func() {
// Construct an instance of the GetObjectTaggingOptions model
bucket := "testString"
key := "testString"
tagging := true
getObjectTaggingOptionsModel := ibmCloudObjectStorageS3ApiService.NewGetObjectTaggingOptions(bucket, key, tagging)
getObjectTaggingOptionsModel.SetBucket("testString")
getObjectTaggingOptionsModel.SetKey("testString")
getObjectTaggingOptionsModel.SetTagging(true)
getObjectTaggingOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(getObjectTaggingOptionsModel).ToNot(BeNil())
Expect(getObjectTaggingOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(getObjectTaggingOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(getObjectTaggingOptionsModel.Tagging).To(Equal(core.BoolPtr(true)))
Expect(getObjectTaggingOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewGetPublicAccessBlockOptions successfully`, func() {
// Construct an instance of the GetPublicAccessBlockOptions model
bucket := "testString"
publicAccessBlock := true
getPublicAccessBlockOptionsModel := ibmCloudObjectStorageS3ApiService.NewGetPublicAccessBlockOptions(bucket, publicAccessBlock)
getPublicAccessBlockOptionsModel.SetBucket("testString")
getPublicAccessBlockOptionsModel.SetPublicAccessBlock(true)
getPublicAccessBlockOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(getPublicAccessBlockOptionsModel).ToNot(BeNil())
Expect(getPublicAccessBlockOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(getPublicAccessBlockOptionsModel.PublicAccessBlock).To(Equal(core.BoolPtr(true)))
Expect(getPublicAccessBlockOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewHeadBucketOptions successfully`, func() {
// Construct an instance of the HeadBucketOptions model
bucket := "testString"
headBucketOptionsModel := ibmCloudObjectStorageS3ApiService.NewHeadBucketOptions(bucket)
headBucketOptionsModel.SetBucket("testString")
headBucketOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(headBucketOptionsModel).ToNot(BeNil())
Expect(headBucketOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(headBucketOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewHeadObjectOptions successfully`, func() {
// Construct an instance of the HeadObjectOptions model
bucket := "testString"
key := "testString"
headObjectOptionsModel := ibmCloudObjectStorageS3ApiService.NewHeadObjectOptions(bucket, key)
headObjectOptionsModel.SetBucket("testString")
headObjectOptionsModel.SetKey("testString")
headObjectOptionsModel.SetIfMatch("testString")
headObjectOptionsModel.SetIfModifiedSince(CreateMockDateTime())
headObjectOptionsModel.SetIfNoneMatch("testString")
headObjectOptionsModel.SetIfUnmodifiedSince(CreateMockDateTime())
headObjectOptionsModel.SetRange("testString")
headObjectOptionsModel.SetXAmzServerSideEncryptionCustomerAlgorithm("testString")
headObjectOptionsModel.SetXAmzServerSideEncryptionCustomerKey("testString")
headObjectOptionsModel.SetXAmzServerSideEncryptionCustomerKeyMD5("testString")
headObjectOptionsModel.SetPartNumber(int64(38))
headObjectOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(headObjectOptionsModel).ToNot(BeNil())
Expect(headObjectOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(headObjectOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(headObjectOptionsModel.IfMatch).To(Equal(core.StringPtr("testString")))
Expect(headObjectOptionsModel.IfModifiedSince).To(Equal(CreateMockDateTime()))
Expect(headObjectOptionsModel.IfNoneMatch).To(Equal(core.StringPtr("testString")))
Expect(headObjectOptionsModel.IfUnmodifiedSince).To(Equal(CreateMockDateTime()))
Expect(headObjectOptionsModel.Range).To(Equal(core.StringPtr("testString")))
Expect(headObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm).To(Equal(core.StringPtr("testString")))
Expect(headObjectOptionsModel.XAmzServerSideEncryptionCustomerKey).To(Equal(core.StringPtr("testString")))
Expect(headObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5).To(Equal(core.StringPtr("testString")))
Expect(headObjectOptionsModel.PartNumber).To(Equal(core.Int64Ptr(int64(38))))
Expect(headObjectOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewInitiateMultipartUploadOptions successfully`, func() {
// Construct an instance of the InitiateMultipartUploadOptions model
bucket := "testString"
uploads := true
key := "testString"
body := "testString"
initiateMultipartUploadOptionsModel := ibmCloudObjectStorageS3ApiService.NewInitiateMultipartUploadOptions(bucket, uploads, key, body)
initiateMultipartUploadOptionsModel.SetBucket("testString")
initiateMultipartUploadOptionsModel.SetUploads(true)
initiateMultipartUploadOptionsModel.SetKey("testString")
initiateMultipartUploadOptionsModel.SetBody("testString")
initiateMultipartUploadOptionsModel.SetIfMatch("testString")
initiateMultipartUploadOptionsModel.SetIfNoneMatch("testString")
initiateMultipartUploadOptionsModel.SetIfUnmodifiedSince(CreateMockDateTime())
initiateMultipartUploadOptionsModel.SetCacheControl("testString")
initiateMultipartUploadOptionsModel.SetContentDisposition("testString")
initiateMultipartUploadOptionsModel.SetContentEncoding("testString")
initiateMultipartUploadOptionsModel.SetContentLanguage("testString")
initiateMultipartUploadOptionsModel.SetExpires(CreateMockDateTime())
initiateMultipartUploadOptionsModel.SetXAmzServerSideEncryption("AES256")
initiateMultipartUploadOptionsModel.SetXAmzWebsiteRedirectLocation("testString")
initiateMultipartUploadOptionsModel.SetXAmzServerSideEncryptionCustomerAlgorithm("testString")
initiateMultipartUploadOptionsModel.SetXAmzServerSideEncryptionCustomerKey("testString")
initiateMultipartUploadOptionsModel.SetXAmzServerSideEncryptionCustomerKeyMD5("testString")
initiateMultipartUploadOptionsModel.SetXAmzTagging("testString")
initiateMultipartUploadOptionsModel.SetXAmzAcl("private")
initiateMultipartUploadOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(initiateMultipartUploadOptionsModel).ToNot(BeNil())
Expect(initiateMultipartUploadOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.Uploads).To(Equal(core.BoolPtr(true)))
Expect(initiateMultipartUploadOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.IfMatch).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.IfNoneMatch).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.IfUnmodifiedSince).To(Equal(CreateMockDateTime()))
Expect(initiateMultipartUploadOptionsModel.CacheControl).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.ContentDisposition).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.ContentEncoding).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.ContentLanguage).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.Expires).To(Equal(CreateMockDateTime()))
Expect(initiateMultipartUploadOptionsModel.XAmzServerSideEncryption).To(Equal(core.StringPtr("AES256")))
Expect(initiateMultipartUploadOptionsModel.XAmzWebsiteRedirectLocation).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerKey).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.XAmzTagging).To(Equal(core.StringPtr("testString")))
Expect(initiateMultipartUploadOptionsModel.XAmzAcl).To(Equal(core.StringPtr("private")))
Expect(initiateMultipartUploadOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewListBucketsOptions successfully`, func() {
// Construct an instance of the ListBucketsOptions model
ibmServiceInstanceID := "d6f76k03-6k4f-4a82-n165-697654o63903"
listBucketsOptionsModel := ibmCloudObjectStorageS3ApiService.NewListBucketsOptions(ibmServiceInstanceID)
listBucketsOptionsModel.SetIbmServiceInstanceID("d6f76k03-6k4f-4a82-n165-697654o63903")
listBucketsOptionsModel.SetExtended(true)
listBucketsOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(listBucketsOptionsModel).ToNot(BeNil())
Expect(listBucketsOptionsModel.IbmServiceInstanceID).To(Equal(core.StringPtr("d6f76k03-6k4f-4a82-n165-697654o63903")))
Expect(listBucketsOptionsModel.Extended).To(Equal(core.BoolPtr(true)))
Expect(listBucketsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewListMultipartUploadsOptions successfully`, func() {
// Construct an instance of the ListMultipartUploadsOptions model
bucket := "testString"
uploads := true
listMultipartUploadsOptionsModel := ibmCloudObjectStorageS3ApiService.NewListMultipartUploadsOptions(bucket, uploads)
listMultipartUploadsOptionsModel.SetBucket("testString")
listMultipartUploadsOptionsModel.SetUploads(true)
listMultipartUploadsOptionsModel.SetDelimiter("testString")
listMultipartUploadsOptionsModel.SetEncodingType("url")
listMultipartUploadsOptionsModel.SetKeyMarker("testString")
listMultipartUploadsOptionsModel.SetMaxUploads(int64(38))
listMultipartUploadsOptionsModel.SetPrefix("testString")
listMultipartUploadsOptionsModel.SetUploadIdMarker("testString")
listMultipartUploadsOptionsModel.SetPaginationLimit("testString")
listMultipartUploadsOptionsModel.SetPaginationToken("testString")
listMultipartUploadsOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(listMultipartUploadsOptionsModel).ToNot(BeNil())
Expect(listMultipartUploadsOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(listMultipartUploadsOptionsModel.Uploads).To(Equal(core.BoolPtr(true)))
Expect(listMultipartUploadsOptionsModel.Delimiter).To(Equal(core.StringPtr("testString")))
Expect(listMultipartUploadsOptionsModel.EncodingType).To(Equal(core.StringPtr("url")))
Expect(listMultipartUploadsOptionsModel.KeyMarker).To(Equal(core.StringPtr("testString")))
Expect(listMultipartUploadsOptionsModel.MaxUploads).To(Equal(core.Int64Ptr(int64(38))))
Expect(listMultipartUploadsOptionsModel.Prefix).To(Equal(core.StringPtr("testString")))
Expect(listMultipartUploadsOptionsModel.UploadIdMarker).To(Equal(core.StringPtr("testString")))
Expect(listMultipartUploadsOptionsModel.PaginationLimit).To(Equal(core.StringPtr("testString")))
Expect(listMultipartUploadsOptionsModel.PaginationToken).To(Equal(core.StringPtr("testString")))
Expect(listMultipartUploadsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewListObjectsOptions successfully`, func() {
// Construct an instance of the ListObjectsOptions model
bucket := "testString"
listObjectsOptionsModel := ibmCloudObjectStorageS3ApiService.NewListObjectsOptions(bucket)
listObjectsOptionsModel.SetBucket("testString")
listObjectsOptionsModel.SetDelimiter("testString")
listObjectsOptionsModel.SetEncodingType("url")
listObjectsOptionsModel.SetMarker("testString")
listObjectsOptionsModel.SetMaxKeys(int64(38))
listObjectsOptionsModel.SetPrefix("testString")
listObjectsOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(listObjectsOptionsModel).ToNot(BeNil())
Expect(listObjectsOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(listObjectsOptionsModel.Delimiter).To(Equal(core.StringPtr("testString")))
Expect(listObjectsOptionsModel.EncodingType).To(Equal(core.StringPtr("url")))
Expect(listObjectsOptionsModel.Marker).To(Equal(core.StringPtr("testString")))
Expect(listObjectsOptionsModel.MaxKeys).To(Equal(core.Int64Ptr(int64(38))))
Expect(listObjectsOptionsModel.Prefix).To(Equal(core.StringPtr("testString")))
Expect(listObjectsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewListObjectsV2Options successfully`, func() {
// Construct an instance of the ListObjectsV2Options model
bucket := "testString"
listType := "2"
listObjectsV2OptionsModel := ibmCloudObjectStorageS3ApiService.NewListObjectsV2Options(bucket, listType)
listObjectsV2OptionsModel.SetBucket("testString")
listObjectsV2OptionsModel.SetListType("2")
listObjectsV2OptionsModel.SetDelimiter("testString")
listObjectsV2OptionsModel.SetEncodingType("url")
listObjectsV2OptionsModel.SetMaxKeys(int64(38))
listObjectsV2OptionsModel.SetPrefix("testString")
listObjectsV2OptionsModel.SetContinuationToken("testString")
listObjectsV2OptionsModel.SetFetchOwner(true)
listObjectsV2OptionsModel.SetStartAfter("testString")
listObjectsV2OptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(listObjectsV2OptionsModel).ToNot(BeNil())
Expect(listObjectsV2OptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(listObjectsV2OptionsModel.ListType).To(Equal(core.StringPtr("2")))
Expect(listObjectsV2OptionsModel.Delimiter).To(Equal(core.StringPtr("testString")))
Expect(listObjectsV2OptionsModel.EncodingType).To(Equal(core.StringPtr("url")))
Expect(listObjectsV2OptionsModel.MaxKeys).To(Equal(core.Int64Ptr(int64(38))))
Expect(listObjectsV2OptionsModel.Prefix).To(Equal(core.StringPtr("testString")))
Expect(listObjectsV2OptionsModel.ContinuationToken).To(Equal(core.StringPtr("testString")))
Expect(listObjectsV2OptionsModel.FetchOwner).To(Equal(core.BoolPtr(true)))
Expect(listObjectsV2OptionsModel.StartAfter).To(Equal(core.StringPtr("testString")))
Expect(listObjectsV2OptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewListPartsOptions successfully`, func() {
// Construct an instance of the ListPartsOptions model
bucket := "testString"
key := "testString"
uploadID := "testString"
listPartsOptionsModel := ibmCloudObjectStorageS3ApiService.NewListPartsOptions(bucket, key, uploadID)
listPartsOptionsModel.SetBucket("testString")
listPartsOptionsModel.SetKey("testString")
listPartsOptionsModel.SetUploadID("testString")
listPartsOptionsModel.SetMaxParts(int64(38))
listPartsOptionsModel.SetPartNumberMarker(int64(38))
listPartsOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(listPartsOptionsModel).ToNot(BeNil())
Expect(listPartsOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(listPartsOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(listPartsOptionsModel.UploadID).To(Equal(core.StringPtr("testString")))
Expect(listPartsOptionsModel.MaxParts).To(Equal(core.Int64Ptr(int64(38))))
Expect(listPartsOptionsModel.PartNumberMarker).To(Equal(core.Int64Ptr(int64(38))))
Expect(listPartsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewPutBucketAclOptions successfully`, func() {
// Construct an instance of the PutBucketAclOptions model
bucket := "testString"
acl := true
putBucketAclOptionsModel := ibmCloudObjectStorageS3ApiService.NewPutBucketAclOptions(bucket, acl)
putBucketAclOptionsModel.SetBucket("testString")
putBucketAclOptionsModel.SetAcl(true)
putBucketAclOptionsModel.SetXAmzAcl("private")
putBucketAclOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(putBucketAclOptionsModel).ToNot(BeNil())
Expect(putBucketAclOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(putBucketAclOptionsModel.Acl).To(Equal(core.BoolPtr(true)))
Expect(putBucketAclOptionsModel.XAmzAcl).To(Equal(core.StringPtr("private")))
Expect(putBucketAclOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewPutBucketCorsOptions successfully`, func() {
// Construct an instance of the PutBucketCorsOptions model
bucket := "testString"
cors := true
body := "testString"
putBucketCorsOptionsModel := ibmCloudObjectStorageS3ApiService.NewPutBucketCorsOptions(bucket, cors, body)
putBucketCorsOptionsModel.SetBucket("testString")
putBucketCorsOptionsModel.SetCors(true)
putBucketCorsOptionsModel.SetBody("testString")
putBucketCorsOptionsModel.SetContentMD5("testString")
putBucketCorsOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(putBucketCorsOptionsModel).ToNot(BeNil())
Expect(putBucketCorsOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(putBucketCorsOptionsModel.Cors).To(Equal(core.BoolPtr(true)))
Expect(putBucketCorsOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(putBucketCorsOptionsModel.ContentMD5).To(Equal(core.StringPtr("testString")))
Expect(putBucketCorsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewPutBucketLifecycleConfigurationOptions successfully`, func() {
// Construct an instance of the PutBucketLifecycleConfigurationOptions model
bucket := "testString"
lifecycle := true
body := "testString"
putBucketLifecycleConfigurationOptionsModel := ibmCloudObjectStorageS3ApiService.NewPutBucketLifecycleConfigurationOptions(bucket, lifecycle, body)
putBucketLifecycleConfigurationOptionsModel.SetBucket("testString")
putBucketLifecycleConfigurationOptionsModel.SetLifecycle(true)
putBucketLifecycleConfigurationOptionsModel.SetBody("testString")
putBucketLifecycleConfigurationOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(putBucketLifecycleConfigurationOptionsModel).ToNot(BeNil())
Expect(putBucketLifecycleConfigurationOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(putBucketLifecycleConfigurationOptionsModel.Lifecycle).To(Equal(core.BoolPtr(true)))
Expect(putBucketLifecycleConfigurationOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(putBucketLifecycleConfigurationOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewPutBucketProtectionConfigurationOptions successfully`, func() {
// Construct an instance of the PutBucketProtectionConfigurationOptions model
bucket := "testString"
protection := true
body := "testString"
putBucketProtectionConfigurationOptionsModel := ibmCloudObjectStorageS3ApiService.NewPutBucketProtectionConfigurationOptions(bucket, protection, body)
putBucketProtectionConfigurationOptionsModel.SetBucket("testString")
putBucketProtectionConfigurationOptionsModel.SetProtection(true)
putBucketProtectionConfigurationOptionsModel.SetBody("testString")
putBucketProtectionConfigurationOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(putBucketProtectionConfigurationOptionsModel).ToNot(BeNil())
Expect(putBucketProtectionConfigurationOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(putBucketProtectionConfigurationOptionsModel.Protection).To(Equal(core.BoolPtr(true)))
Expect(putBucketProtectionConfigurationOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(putBucketProtectionConfigurationOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewPutBucketWebsiteOptions successfully`, func() {
// Construct an instance of the PutBucketWebsiteOptions model
bucket := "testString"
website := true
body := "testString"
putBucketWebsiteOptionsModel := ibmCloudObjectStorageS3ApiService.NewPutBucketWebsiteOptions(bucket, website, body)
putBucketWebsiteOptionsModel.SetBucket("testString")
putBucketWebsiteOptionsModel.SetWebsite(true)
putBucketWebsiteOptionsModel.SetBody("testString")
putBucketWebsiteOptionsModel.SetContentMD5("testString")
putBucketWebsiteOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(putBucketWebsiteOptionsModel).ToNot(BeNil())
Expect(putBucketWebsiteOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(putBucketWebsiteOptionsModel.Website).To(Equal(core.BoolPtr(true)))
Expect(putBucketWebsiteOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(putBucketWebsiteOptionsModel.ContentMD5).To(Equal(core.StringPtr("testString")))
Expect(putBucketWebsiteOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewPutObjectAclOptions successfully`, func() {
// Construct an instance of the PutObjectAclOptions model
bucket := "testString"
key := "testString"
acl := true
body := "testString"
putObjectAclOptionsModel := ibmCloudObjectStorageS3ApiService.NewPutObjectAclOptions(bucket, key, acl, body)
putObjectAclOptionsModel.SetBucket("testString")
putObjectAclOptionsModel.SetKey("testString")
putObjectAclOptionsModel.SetAcl(true)
putObjectAclOptionsModel.SetBody("testString")
putObjectAclOptionsModel.SetXAmzAcl("private")
putObjectAclOptionsModel.SetContentMD5("testString")
putObjectAclOptionsModel.SetXAmzGrantFullControl("testString")
putObjectAclOptionsModel.SetXAmzGrantRead("testString")
putObjectAclOptionsModel.SetXAmzGrantReadAcp("testString")
putObjectAclOptionsModel.SetXAmzGrantWrite("testString")
putObjectAclOptionsModel.SetXAmzGrantWriteAcp("testString")
putObjectAclOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(putObjectAclOptionsModel).ToNot(BeNil())
Expect(putObjectAclOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(putObjectAclOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(putObjectAclOptionsModel.Acl).To(Equal(core.BoolPtr(true)))
Expect(putObjectAclOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(putObjectAclOptionsModel.XAmzAcl).To(Equal(core.StringPtr("private")))
Expect(putObjectAclOptionsModel.ContentMD5).To(Equal(core.StringPtr("testString")))
Expect(putObjectAclOptionsModel.XAmzGrantFullControl).To(Equal(core.StringPtr("testString")))
Expect(putObjectAclOptionsModel.XAmzGrantRead).To(Equal(core.StringPtr("testString")))
Expect(putObjectAclOptionsModel.XAmzGrantReadAcp).To(Equal(core.StringPtr("testString")))
Expect(putObjectAclOptionsModel.XAmzGrantWrite).To(Equal(core.StringPtr("testString")))
Expect(putObjectAclOptionsModel.XAmzGrantWriteAcp).To(Equal(core.StringPtr("testString")))
Expect(putObjectAclOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewPutObjectOptions successfully`, func() {
// Construct an instance of the PutObjectOptions model
bucket := "testString"
key := "testString"
body := "testString"
putObjectOptionsModel := ibmCloudObjectStorageS3ApiService.NewPutObjectOptions(bucket, key, body)
putObjectOptionsModel.SetBucket("testString")
putObjectOptionsModel.SetKey("testString")
putObjectOptionsModel.SetBody("testString")
putObjectOptionsModel.SetXAmzAcl("private")
putObjectOptionsModel.SetIfMatch("testString")
putObjectOptionsModel.SetIfNoneMatch("testString")
putObjectOptionsModel.SetIfUnmodifiedSince(CreateMockDateTime())
putObjectOptionsModel.SetCacheControl("testString")
putObjectOptionsModel.SetContentDisposition("testString")
putObjectOptionsModel.SetContentEncoding("testString")
putObjectOptionsModel.SetContentLanguage("testString")
putObjectOptionsModel.SetContentLength(int64(38))
putObjectOptionsModel.SetContentMD5("testString")
putObjectOptionsModel.SetExpires(CreateMockDateTime())
putObjectOptionsModel.SetXAmzServerSideEncryption("AES256")
putObjectOptionsModel.SetXAmzWebsiteRedirectLocation("testString")
putObjectOptionsModel.SetXAmzServerSideEncryptionCustomerAlgorithm("testString")
putObjectOptionsModel.SetXAmzServerSideEncryptionCustomerKey("testString")
putObjectOptionsModel.SetXAmzServerSideEncryptionCustomerKeyMD5("testString")
putObjectOptionsModel.SetXAmzTagging("testString")
putObjectOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(putObjectOptionsModel).ToNot(BeNil())
Expect(putObjectOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.XAmzAcl).To(Equal(core.StringPtr("private")))
Expect(putObjectOptionsModel.IfMatch).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.IfNoneMatch).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.IfUnmodifiedSince).To(Equal(CreateMockDateTime()))
Expect(putObjectOptionsModel.CacheControl).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.ContentDisposition).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.ContentEncoding).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.ContentLanguage).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.ContentLength).To(Equal(core.Int64Ptr(int64(38))))
Expect(putObjectOptionsModel.ContentMD5).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.Expires).To(Equal(CreateMockDateTime()))
Expect(putObjectOptionsModel.XAmzServerSideEncryption).To(Equal(core.StringPtr("AES256")))
Expect(putObjectOptionsModel.XAmzWebsiteRedirectLocation).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.XAmzServerSideEncryptionCustomerKey).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.XAmzTagging).To(Equal(core.StringPtr("testString")))
Expect(putObjectOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewPutObjectTaggingOptions successfully`, func() {
// Construct an instance of the PutObjectTaggingOptions model
bucket := "testString"
key := "testString"
tagging := true
body := "testString"
putObjectTaggingOptionsModel := ibmCloudObjectStorageS3ApiService.NewPutObjectTaggingOptions(bucket, key, tagging, body)
putObjectTaggingOptionsModel.SetBucket("testString")
putObjectTaggingOptionsModel.SetKey("testString")
putObjectTaggingOptionsModel.SetTagging(true)
putObjectTaggingOptionsModel.SetBody("testString")
putObjectTaggingOptionsModel.SetContentMD5("testString")
putObjectTaggingOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(putObjectTaggingOptionsModel).ToNot(BeNil())
Expect(putObjectTaggingOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(putObjectTaggingOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(putObjectTaggingOptionsModel.Tagging).To(Equal(core.BoolPtr(true)))
Expect(putObjectTaggingOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(putObjectTaggingOptionsModel.ContentMD5).To(Equal(core.StringPtr("testString")))
Expect(putObjectTaggingOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewPutPublicAccessBlockOptions successfully`, func() {
// Construct an instance of the PutPublicAccessBlockOptions model
bucket := "testString"
publicAccessBlock := true
body := "testString"
putPublicAccessBlockOptionsModel := ibmCloudObjectStorageS3ApiService.NewPutPublicAccessBlockOptions(bucket, publicAccessBlock, body)
putPublicAccessBlockOptionsModel.SetBucket("testString")
putPublicAccessBlockOptionsModel.SetPublicAccessBlock(true)
putPublicAccessBlockOptionsModel.SetBody("testString")
putPublicAccessBlockOptionsModel.SetContentMD5("testString")
putPublicAccessBlockOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(putPublicAccessBlockOptionsModel).ToNot(BeNil())
Expect(putPublicAccessBlockOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(putPublicAccessBlockOptionsModel.PublicAccessBlock).To(Equal(core.BoolPtr(true)))
Expect(putPublicAccessBlockOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(putPublicAccessBlockOptionsModel.ContentMD5).To(Equal(core.StringPtr("testString")))
Expect(putPublicAccessBlockOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewRestoreObjectOptions successfully`, func() {
// Construct an instance of the RestoreObjectOptions model
bucket := "testString"
key := "testString"
restore := true
body := "testString"
restoreObjectOptionsModel := ibmCloudObjectStorageS3ApiService.NewRestoreObjectOptions(bucket, key, restore, body)
restoreObjectOptionsModel.SetBucket("testString")
restoreObjectOptionsModel.SetKey("testString")
restoreObjectOptionsModel.SetRestore(true)
restoreObjectOptionsModel.SetBody("testString")
restoreObjectOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(restoreObjectOptionsModel).ToNot(BeNil())
Expect(restoreObjectOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(restoreObjectOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(restoreObjectOptionsModel.Restore).To(Equal(core.BoolPtr(true)))
Expect(restoreObjectOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(restoreObjectOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewUploadPartCopyOptions successfully`, func() {
// Construct an instance of the UploadPartCopyOptions model
bucket := "testString"
xAmzCopySource := "testString"
key := "testString"
partNumber := int64(38)
uploadID := "testString"
uploadPartCopyOptionsModel := ibmCloudObjectStorageS3ApiService.NewUploadPartCopyOptions(bucket, xAmzCopySource, key, partNumber, uploadID)
uploadPartCopyOptionsModel.SetBucket("testString")
uploadPartCopyOptionsModel.SetXAmzCopySource("testString")
uploadPartCopyOptionsModel.SetKey("testString")
uploadPartCopyOptionsModel.SetPartNumber(int64(38))
uploadPartCopyOptionsModel.SetUploadID("testString")
uploadPartCopyOptionsModel.SetXAmzCopySourceIfMatch("testString")
uploadPartCopyOptionsModel.SetXAmzCopySourceIfModifiedSince(CreateMockDateTime())
uploadPartCopyOptionsModel.SetXAmzCopySourceIfNoneMatch("testString")
uploadPartCopyOptionsModel.SetXAmzCopySourceIfUnmodifiedSince(CreateMockDateTime())
uploadPartCopyOptionsModel.SetXAmzCopySourceRange("testString")
uploadPartCopyOptionsModel.SetXAmzServerSideEncryptionCustomerAlgorithm("testString")
uploadPartCopyOptionsModel.SetXAmzServerSideEncryptionCustomerKey("testString")
uploadPartCopyOptionsModel.SetXAmzServerSideEncryptionCustomerKeyMD5("testString")
uploadPartCopyOptionsModel.SetXAmzCopySourceServerSideEncryptionCustomerAlgorithm("testString")
uploadPartCopyOptionsModel.SetXAmzCopySourceServerSideEncryptionCustomerKey("testString")
uploadPartCopyOptionsModel.SetXAmzCopySourceServerSideEncryptionCustomerKeyMD5("testString")
uploadPartCopyOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(uploadPartCopyOptionsModel).ToNot(BeNil())
Expect(uploadPartCopyOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.XAmzCopySource).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.PartNumber).To(Equal(core.Int64Ptr(int64(38))))
Expect(uploadPartCopyOptionsModel.UploadID).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.XAmzCopySourceIfMatch).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.XAmzCopySourceIfModifiedSince).To(Equal(CreateMockDateTime()))
Expect(uploadPartCopyOptionsModel.XAmzCopySourceIfNoneMatch).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.XAmzCopySourceIfUnmodifiedSince).To(Equal(CreateMockDateTime()))
Expect(uploadPartCopyOptionsModel.XAmzCopySourceRange).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerKey).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerAlgorithm).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKey).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.XAmzCopySourceServerSideEncryptionCustomerKeyMD5).To(Equal(core.StringPtr("testString")))
Expect(uploadPartCopyOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
It(`Invoke NewUploadPartOptions successfully`, func() {
// Construct an instance of the UploadPartOptions model
bucket := "testString"
key := "testString"
partNumber := int64(38)
uploadID := "testString"
body := "testString"
uploadPartOptionsModel := ibmCloudObjectStorageS3ApiService.NewUploadPartOptions(bucket, key, partNumber, uploadID, body)
uploadPartOptionsModel.SetBucket("testString")
uploadPartOptionsModel.SetKey("testString")
uploadPartOptionsModel.SetPartNumber(int64(38))
uploadPartOptionsModel.SetUploadID("testString")
uploadPartOptionsModel.SetBody("testString")
uploadPartOptionsModel.SetContentLength(int64(38))
uploadPartOptionsModel.SetContentMD5("testString")
uploadPartOptionsModel.SetXAmzServerSideEncryptionCustomerAlgorithm("testString")
uploadPartOptionsModel.SetXAmzServerSideEncryptionCustomerKey("testString")
uploadPartOptionsModel.SetXAmzServerSideEncryptionCustomerKeyMD5("testString")
uploadPartOptionsModel.SetXAmzRequestPayer("requester")
uploadPartOptionsModel.SetXAmzExpectedBucketOwner("testString")
uploadPartOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
Expect(uploadPartOptionsModel).ToNot(BeNil())
Expect(uploadPartOptionsModel.Bucket).To(Equal(core.StringPtr("testString")))
Expect(uploadPartOptionsModel.Key).To(Equal(core.StringPtr("testString")))
Expect(uploadPartOptionsModel.PartNumber).To(Equal(core.Int64Ptr(int64(38))))
Expect(uploadPartOptionsModel.UploadID).To(Equal(core.StringPtr("testString")))
Expect(uploadPartOptionsModel.Body).To(Equal(core.StringPtr("testString")))
Expect(uploadPartOptionsModel.ContentLength).To(Equal(core.Int64Ptr(int64(38))))
Expect(uploadPartOptionsModel.ContentMD5).To(Equal(core.StringPtr("testString")))
Expect(uploadPartOptionsModel.XAmzServerSideEncryptionCustomerAlgorithm).To(Equal(core.StringPtr("testString")))
Expect(uploadPartOptionsModel.XAmzServerSideEncryptionCustomerKey).To(Equal(core.StringPtr("testString")))
Expect(uploadPartOptionsModel.XAmzServerSideEncryptionCustomerKeyMD5).To(Equal(core.StringPtr("testString")))
Expect(uploadPartOptionsModel.XAmzRequestPayer).To(Equal(core.StringPtr("requester")))
Expect(uploadPartOptionsModel.XAmzExpectedBucketOwner).To(Equal(core.StringPtr("testString")))
Expect(uploadPartOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
})
})
})
Describe(`Utility function tests`, func() {
It(`Invoke CreateMockByteArray() successfully`, func() {
mockByteArray := CreateMockByteArray("This is a test")
Expect(mockByteArray).ToNot(BeNil())
})
It(`Invoke CreateMockUUID() successfully`, func() {
mockUUID := CreateMockUUID("9fab83da-98cb-4f18-a7ba-b6f0435c9673")
Expect(mockUUID).ToNot(BeNil())
})
It(`Invoke CreateMockReader() successfully`, func() {
mockReader := CreateMockReader("This is a test.")
Expect(mockReader).ToNot(BeNil())
})
It(`Invoke CreateMockDate() successfully`, func() {
mockDate := CreateMockDate()
Expect(mockDate).ToNot(BeNil())
})
It(`Invoke CreateMockDateTime() successfully`, func() {
mockDateTime := CreateMockDateTime()
Expect(mockDateTime).ToNot(BeNil())
})
})
})
//
// Utility functions used by the generated test code
//
func CreateMockByteArray(mockData string) *[]byte {
ba := make([]byte, 0)
ba = append(ba, mockData...)
return &ba
}
func CreateMockUUID(mockData string) *strfmt.UUID {
uuid := strfmt.UUID(mockData)
return &uuid
}
func CreateMockReader(mockData string) io.ReadCloser {
return ioutil.NopCloser(bytes.NewReader([]byte(mockData)))
}
func CreateMockDate() *strfmt.Date {
d := strfmt.Date(time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC))
return &d
}
func CreateMockDateTime() *strfmt.DateTime {
d := strfmt.DateTime(time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC))
return &d
}
func SetTestEnvironment(testEnvironment map[string]string) {
for key, value := range testEnvironment {
os.Setenv(key, value)
}
}
func ClearTestEnvironment(testEnvironment map[string]string) {
for key := range testEnvironment {
os.Unsetenv(key)
}
}
|
package nats
import (
"context"
"fmt"
"log"
"github.com/batchcorp/plumber-schemas/build/go/protos/encoding"
cenats "github.com/cloudevents/sdk-go/protocol/nats/v2"
cloudevents "github.com/cloudevents/sdk-go/v2"
"github.com/pkg/errors"
"github.com/batchcorp/plumber-schemas/build/go/protos/opts"
"github.com/batchcorp/plumber-schemas/build/go/protos/records"
"github.com/batchcorp/plumber/util"
"github.com/batchcorp/plumber/validate"
)
func (n *Nats) Write(ctx context.Context, writeOpts *opts.WriteOptions, errorCh chan<- *records.ErrorRecord, messages ...*records.WriteRecord) error {
if err := validateWriteOptions(writeOpts); err != nil {
return errors.Wrap(err, "unable to validate write options")
}
if writeOpts.EncodeOptions != nil && writeOpts.EncodeOptions.EncodeType == encoding.EncodeType_ENCODE_TYPE_CLOUDEVENT {
return n.writeCloudEvents(ctx, writeOpts, errorCh, messages...)
}
subject := writeOpts.Nats.Args.Subject
for _, msg := range messages {
if err := n.Client.Publish(subject, []byte(msg.Input)); err != nil {
util.WriteError(n.log, errorCh, fmt.Errorf("unable to publish message to subject '%s': %s", subject, err))
continue
}
return nil
}
return nil
}
func (n *Nats) writeCloudEvents(ctx context.Context, writeOpts *opts.WriteOptions, errorCh chan<- *records.ErrorRecord, messages ...*records.WriteRecord) error {
subject := writeOpts.Nats.Args.Subject
sender, err := cenats.NewSenderFromConn(n.Client, subject)
if err != nil {
return errors.Wrap(err, "unable to create new cloudevents send")
}
// Not performing sender.Close() here since plumber handles connection closing
c, err := cloudevents.NewClient(sender)
if err != nil {
log.Fatalf("Failed to create client, %s", err.Error())
}
for i, msg := range messages {
e, err := util.GenCloudEvent(writeOpts.EncodeOptions.CloudeventSettings, msg)
if err != nil {
util.WriteError(n.log, errorCh, errors.Wrap(err, "unable to generate cloudevents event"))
continue
}
if result := c.Send(ctx, *e); cloudevents.IsUndelivered(result) {
util.WriteError(n.log, errorCh, fmt.Errorf("unable to publish message to subject '%s': %s", subject, result))
continue
} else {
n.log.Debugf("sent: %d, accepted: %t", i, cloudevents.IsACK(result))
}
}
return nil
}
func validateWriteOptions(writeOpts *opts.WriteOptions) error {
if writeOpts == nil {
return validate.ErrEmptyWriteOpts
}
if writeOpts.Nats == nil {
return validate.ErrEmptyBackendGroup
}
if writeOpts.Nats.Args == nil {
return validate.ErrEmptyBackendArgs
}
if writeOpts.Nats.Args.Subject == "" {
return ErrMissingSubject
}
return nil
}
|
package models
import (
"errors"
"go-admin/global"
"go-admin/utils"
)
type Login struct {
Username string `form:"UserName" json:"username" binding:"required"`
Password string `form:"Password" json:"password" binding:"required"`
}
func (l *Login) GetUser() (user SysUser, role SysRole, err error) {
err = global.GDB.Table("sys_user").Where("username = ?", l.Username).Find(&user).Error
if err != nil {
return user, role, errors.New("查找用户失败")
}
if utils.PasswordVerify(user.Password, l.Password) {
return user, role, errors.New("密码不匹配")
}
return
}
func UserLogin(l *Login) (err error, userInter *SysUser) {
var user SysUser
err = global.GDB.Table("sys_user").Where("username = ?", l.Username).Find(&user).Error
if err != nil {
return errors.New("用户不存在"), &user
}
if utils.PasswordVerify(user.Password, l.Password) != true {
return errors.New("密码不正确"), &user
}
err = global.GDB.Model(&user).Association("Roles").Find(&user.Roles)
if err != nil {
return errors.New("查找关联角色失败"), nil
}
return err, &user
}
|
package main
import "fmt"
type Vehicle interface {
Move()
}
type Car struct {
MovementAction string
}
func (c Car) Move() {
fmt.Println(c.MovementAction)
}
type Plane struct {
MovementAction string
}
func (p *Plane) Move() {
fmt.Println(p.MovementAction)
}
func main() {
var v Vehicle = Car{"Drive"}
v.Move()
describe(v)
v = &Plane{"Fly"}
v.Move()
describe(v)
}
func describe(v Vehicle){
fmt.Printf("(%v, %T)\n", v, v)
} |
// Copyright 2022 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package ddl_test
import (
"fmt"
"testing"
"github.com/pingcap/tidb/config"
"github.com/pingcap/tidb/domain"
"github.com/pingcap/tidb/errno"
"github.com/pingcap/tidb/parser/model"
"github.com/pingcap/tidb/store/mockstore"
"github.com/pingcap/tidb/testkit"
"github.com/stretchr/testify/require"
)
func TestRenameIndex(t *testing.T) {
store := testkit.CreateMockStore(t)
tk := testkit.NewTestKit(t, store)
tk.MustExec("use test")
tk.MustExec("create table t (pk int primary key, c int default 1, c1 int default 1, unique key k1(c), key k2(c1))")
// Test rename success
tk.MustExec("alter table t rename index k1 to k3")
tk.MustExec("admin check index t k3")
// Test rename to the same name
tk.MustExec("alter table t rename index k3 to k3")
tk.MustExec("admin check index t k3")
// Test rename on non-exists keys
tk.MustGetErrCode("alter table t rename index x to x", errno.ErrKeyDoesNotExist)
// Test rename on already-exists keys
tk.MustGetErrCode("alter table t rename index k3 to k2", errno.ErrDupKeyName)
tk.MustExec("alter table t rename index k2 to K2")
tk.MustGetErrCode("alter table t rename key k3 to K2", errno.ErrDupKeyName)
}
// See issue: https://github.com/pingcap/tidb/issues/29752
// Ref https://dev.mysql.com/doc/refman/8.0/en/rename-table.html
func TestRenameTableWithLocked(t *testing.T) {
defer config.RestoreFunc()()
config.UpdateGlobal(func(conf *config.Config) {
conf.EnableTableLock = true
})
store := testkit.CreateMockStore(t, mockstore.WithDDLChecker())
tk := testkit.NewTestKit(t, store)
tk.MustExec("create database renamedb")
tk.MustExec("create database renamedb2")
tk.MustExec("use renamedb")
tk.MustExec("DROP TABLE IF EXISTS t1;")
tk.MustExec("CREATE TABLE t1 (a int);")
tk.MustExec("LOCK TABLES t1 WRITE;")
tk.MustGetErrCode("drop database renamedb2;", errno.ErrLockOrActiveTransaction)
tk.MustExec("RENAME TABLE t1 TO t2;")
tk.MustQuery("select * from renamedb.t2").Check(testkit.Rows())
tk.MustExec("UNLOCK TABLES")
tk.MustExec("RENAME TABLE t2 TO t1;")
tk.MustQuery("select * from renamedb.t1").Check(testkit.Rows())
tk.MustExec("LOCK TABLES t1 READ;")
tk.MustGetErrCode("RENAME TABLE t1 TO t2;", errno.ErrTableNotLockedForWrite)
tk.MustExec("UNLOCK TABLES")
tk.MustExec("drop database renamedb")
}
func TestRenameTable2(t *testing.T) {
isAlterTable := false
renameTableTest(t, "rename table %s to %s", isAlterTable)
}
func TestAlterTableRenameTable(t *testing.T) {
isAlterTable := true
renameTableTest(t, "alter table %s rename to %s", isAlterTable)
}
func renameTableTest(t *testing.T, sql string, isAlterTable bool) {
store := testkit.CreateMockStore(t, mockstore.WithDDLChecker())
tk := testkit.NewTestKit(t, store)
tk.MustExec("use test")
tk.MustGetErrCode("rename table tb1 to tb2;", errno.ErrNoSuchTable)
// for different databases
tk.MustExec("create table t (c1 int, c2 int)")
tk.MustExec("insert t values (1, 1), (2, 2)")
ctx := tk.Session()
is := domain.GetDomain(ctx).InfoSchema()
oldTblInfo, err := is.TableByName(model.NewCIStr("test"), model.NewCIStr("t"))
require.NoError(t, err)
oldTblID := oldTblInfo.Meta().ID
tk.MustExec("create database test1")
tk.MustExec("use test1")
tk.MustExec(fmt.Sprintf(sql, "test.t", "test1.t1"))
is = domain.GetDomain(ctx).InfoSchema()
newTblInfo, err := is.TableByName(model.NewCIStr("test1"), model.NewCIStr("t1"))
require.NoError(t, err)
require.Equal(t, oldTblID, newTblInfo.Meta().ID)
tk.MustQuery("select * from t1").Check(testkit.Rows("1 1", "2 2"))
tk.MustExec("use test")
// Make sure t doesn't exist.
tk.MustExec("create table t (c1 int, c2 int)")
tk.MustExec("drop table t")
// for the same database
tk.MustExec("use test1")
tk.MustExec(fmt.Sprintf(sql, "t1", "t2"))
is = domain.GetDomain(ctx).InfoSchema()
newTblInfo, err = is.TableByName(model.NewCIStr("test1"), model.NewCIStr("t2"))
require.NoError(t, err)
require.Equal(t, oldTblID, newTblInfo.Meta().ID)
tk.MustQuery("select * from t2").Check(testkit.Rows("1 1", "2 2"))
isExist := is.TableExists(model.NewCIStr("test1"), model.NewCIStr("t1"))
require.False(t, isExist)
tk.MustQuery("show tables").Check(testkit.Rows("t2"))
// for failure case
failSQL := fmt.Sprintf(sql, "test_not_exist.t", "test_not_exist.t")
tk.MustGetErrCode(failSQL, errno.ErrNoSuchTable)
failSQL = fmt.Sprintf(sql, "test.test_not_exist", "test.test_not_exist")
tk.MustGetErrCode(failSQL, errno.ErrNoSuchTable)
failSQL = fmt.Sprintf(sql, "test.t_not_exist", "test_not_exist.t")
tk.MustGetErrCode(failSQL, errno.ErrNoSuchTable)
failSQL = fmt.Sprintf(sql, "test1.t2", "test_not_exist.t")
tk.MustGetErrCode(failSQL, errno.ErrErrorOnRename)
tk.MustExec("use test1")
tk.MustExec("create table if not exists t_exist (c1 int, c2 int)")
failSQL = fmt.Sprintf(sql, "test1.t2", "test1.t_exist")
tk.MustGetErrCode(failSQL, errno.ErrTableExists)
failSQL = fmt.Sprintf(sql, "test.t_not_exist", "test1.t_exist")
if isAlterTable {
tk.MustGetErrCode(failSQL, errno.ErrNoSuchTable)
} else {
tk.MustGetErrCode(failSQL, errno.ErrTableExists)
}
failSQL = fmt.Sprintf(sql, "test_not_exist.t", "test1.t_exist")
if isAlterTable {
tk.MustGetErrCode(failSQL, errno.ErrNoSuchTable)
} else {
tk.MustGetErrCode(failSQL, errno.ErrTableExists)
}
failSQL = fmt.Sprintf(sql, "test_not_exist.t", "test1.t_not_exist")
if isAlterTable {
tk.MustGetErrCode(failSQL, errno.ErrNoSuchTable)
}
// for the same table name
tk.MustExec("use test1")
tk.MustExec("create table if not exists t (c1 int, c2 int)")
tk.MustExec("create table if not exists t1 (c1 int, c2 int)")
if isAlterTable {
tk.MustExec(fmt.Sprintf(sql, "test1.t", "t"))
tk.MustExec(fmt.Sprintf(sql, "test1.t1", "test1.T1"))
} else {
tk.MustGetErrCode(fmt.Sprintf(sql, "test1.t", "t"), errno.ErrTableExists)
tk.MustGetErrCode(fmt.Sprintf(sql, "test1.t1", "test1.T1"), errno.ErrTableExists)
}
// Test rename table name too long.
tk.MustGetErrCode("rename table test1.t1 to test1.txxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", errno.ErrTooLongIdent)
tk.MustGetErrCode("alter table test1.t1 rename to test1.txxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", errno.ErrTooLongIdent)
tk.MustExec("drop database test1")
}
func TestRenameMultiTables(t *testing.T) {
store := testkit.CreateMockStore(t, mockstore.WithDDLChecker())
tk := testkit.NewTestKit(t, store)
tk.MustExec("use test")
tk.MustExec("create table t1(id int)")
tk.MustExec("create table t2(id int)")
sql := "rename table t1 to t3, t2 to t4"
_, err := tk.Exec(sql)
require.NoError(t, err)
tk.MustExec("drop table t3, t4")
tk.MustExec("create table t1 (c1 int, c2 int)")
tk.MustExec("create table t2 (c1 int, c2 int)")
tk.MustExec("insert t1 values (1, 1), (2, 2)")
tk.MustExec("insert t2 values (1, 1), (2, 2)")
ctx := tk.Session()
is := domain.GetDomain(ctx).InfoSchema()
oldTblInfo1, err := is.TableByName(model.NewCIStr("test"), model.NewCIStr("t1"))
require.NoError(t, err)
oldTblID1 := oldTblInfo1.Meta().ID
oldTblInfo2, err := is.TableByName(model.NewCIStr("test"), model.NewCIStr("t2"))
require.NoError(t, err)
oldTblID2 := oldTblInfo2.Meta().ID
tk.MustExec("create database test1")
tk.MustExec("use test1")
tk.MustExec("rename table test.t1 to test1.t1, test.t2 to test1.t2")
is = domain.GetDomain(ctx).InfoSchema()
newTblInfo1, err := is.TableByName(model.NewCIStr("test1"), model.NewCIStr("t1"))
require.NoError(t, err)
require.Equal(t, oldTblID1, newTblInfo1.Meta().ID)
newTblInfo2, err := is.TableByName(model.NewCIStr("test1"), model.NewCIStr("t2"))
require.NoError(t, err)
require.Equal(t, oldTblID2, newTblInfo2.Meta().ID)
tk.MustQuery("select * from t1").Check(testkit.Rows("1 1", "2 2"))
tk.MustQuery("select * from t2").Check(testkit.Rows("1 1", "2 2"))
// Make sure t1,t2 doesn't exist.
isExist := is.TableExists(model.NewCIStr("test"), model.NewCIStr("t1"))
require.False(t, isExist)
isExist = is.TableExists(model.NewCIStr("test"), model.NewCIStr("t2"))
require.False(t, isExist)
// for the same database
tk.MustExec("use test1")
tk.MustExec("rename table test1.t1 to test1.t3, test1.t2 to test1.t4")
is = domain.GetDomain(ctx).InfoSchema()
newTblInfo1, err = is.TableByName(model.NewCIStr("test1"), model.NewCIStr("t3"))
require.NoError(t, err)
require.Equal(t, oldTblID1, newTblInfo1.Meta().ID)
newTblInfo2, err = is.TableByName(model.NewCIStr("test1"), model.NewCIStr("t4"))
require.NoError(t, err)
require.Equal(t, oldTblID2, newTblInfo2.Meta().ID)
tk.MustQuery("select * from t3").Check(testkit.Rows("1 1", "2 2"))
isExist = is.TableExists(model.NewCIStr("test1"), model.NewCIStr("t1"))
require.False(t, isExist)
tk.MustQuery("select * from t4").Check(testkit.Rows("1 1", "2 2"))
isExist = is.TableExists(model.NewCIStr("test1"), model.NewCIStr("t2"))
require.False(t, isExist)
tk.MustQuery("show tables").Check(testkit.Rows("t3", "t4"))
// for multi tables same database
tk.MustExec("create table t5 (c1 int, c2 int)")
tk.MustExec("insert t5 values (1, 1), (2, 2)")
is = domain.GetDomain(ctx).InfoSchema()
oldTblInfo3, err := is.TableByName(model.NewCIStr("test1"), model.NewCIStr("t5"))
require.NoError(t, err)
oldTblID3 := oldTblInfo3.Meta().ID
tk.MustExec("rename table test1.t3 to test1.t1, test1.t4 to test1.t2, test1.t5 to test1.t3")
is = domain.GetDomain(ctx).InfoSchema()
newTblInfo1, err = is.TableByName(model.NewCIStr("test1"), model.NewCIStr("t1"))
require.NoError(t, err)
require.Equal(t, oldTblID1, newTblInfo1.Meta().ID)
newTblInfo2, err = is.TableByName(model.NewCIStr("test1"), model.NewCIStr("t2"))
require.NoError(t, err)
require.Equal(t, oldTblID2, newTblInfo2.Meta().ID)
newTblInfo3, err := is.TableByName(model.NewCIStr("test1"), model.NewCIStr("t3"))
require.NoError(t, err)
require.Equal(t, oldTblID3, newTblInfo3.Meta().ID)
tk.MustQuery("show tables").Check(testkit.Rows("t1", "t2", "t3"))
// for multi tables different databases
tk.MustExec("use test")
tk.MustExec("rename table test1.t1 to test.t2, test1.t2 to test.t3, test1.t3 to test.t4")
is = domain.GetDomain(ctx).InfoSchema()
newTblInfo1, err = is.TableByName(model.NewCIStr("test"), model.NewCIStr("t2"))
require.NoError(t, err)
require.Equal(t, oldTblID1, newTblInfo1.Meta().ID)
newTblInfo2, err = is.TableByName(model.NewCIStr("test"), model.NewCIStr("t3"))
require.NoError(t, err)
require.Equal(t, oldTblID2, newTblInfo2.Meta().ID)
newTblInfo3, err = is.TableByName(model.NewCIStr("test"), model.NewCIStr("t4"))
require.NoError(t, err)
require.Equal(t, oldTblID3, newTblInfo3.Meta().ID)
tk.MustQuery("show tables").Check(testkit.Rows("t2", "t3", "t4"))
// for failure case
failSQL := "rename table test_not_exist.t to test_not_exist.t, test_not_exist.t to test_not_exist.t"
tk.MustGetErrCode(failSQL, errno.ErrNoSuchTable)
failSQL = "rename table test.test_not_exist to test.test_not_exist, test.test_not_exist to test.test_not_exist"
tk.MustGetErrCode(failSQL, errno.ErrNoSuchTable)
failSQL = "rename table test.t_not_exist to test_not_exist.t, test.t_not_exist to test_not_exist.t"
tk.MustGetErrCode(failSQL, errno.ErrNoSuchTable)
failSQL = "rename table test1.t2 to test_not_exist.t, test1.t2 to test_not_exist.t"
tk.MustGetErrCode(failSQL, errno.ErrNoSuchTable)
tk.MustExec("drop database test1")
tk.MustExec("drop database test")
}
|
package batcher
import (
"encoding/json"
"github.com/dkrieger/redistream"
"github.com/go-redis/redis"
"log"
"os"
"time"
)
// SendBatch aggregates up to BatchConfig.MaxSize entries into one entry,
// adding to Batcher.batchDest() stream
func (b *Batcher) SendBatch(name string) error {
batches := b.getBatches()
batch := batches[name]
// make sure this is the only goroutine consuming this stream
batch.consumerMutex.Lock()
defer batch.consumerMutex.Unlock()
stderr := log.New(os.Stderr, "", 0)
conf := redistream.Config{
MaxLenApprox: 1000,
Block: time.Second,
Count: int64(batch.config.MaxSize),
}
streamClient := redistream.WrapClient(b.redisClient, conf)
fullName := b.StreamPrefix() + name
stderr.Println("stream", fullName)
stderr.Printf("redistream conf:\n%#v\n", conf)
old, err := streamClient.Consume(redistream.ConsumeArgs{
Consumer: b.Consumer(),
Streams: []string{fullName, "0"},
})
if err != nil && err != redis.Nil {
return err
}
oldStream, err := old.Merge(nil)
if err != nil {
return err
}
stderr.Printf("oldStream (pre-reap):\n%#v\n", oldStream)
oldStream, err = b.ReapSome(oldStream, fullName)
if err != nil {
stderr.Printf("ReapSome() error: \nentries: %#v\nname: %s\n%s\n",
oldStream, fullName, err)
}
stderr.Printf("conf:\n%#v\n", conf)
override := conf
override.Count = int64(batch.config.MaxSize - len(oldStream))
stderr.Printf("oldStream:\n%#v\n", oldStream)
stderr.Printf("override:\n%#v\n", override)
stderr.Printf("conf:\n%#v\n", conf)
new := redistream.StreamMap{}
if override.Count > 0 {
new, err = streamClient.Consume(redistream.ConsumeArgs{
Consumer: b.Consumer(),
Streams: []string{fullName, ">"},
Override: &override,
})
if err != nil && err != redis.Nil {
return err
}
}
newStream, err := new.Merge(nil)
if err != nil {
return err
}
newStream, err = b.ReapSome(newStream, fullName)
if err != nil {
stderr.Printf("ReapSome() error: \nentries: %#v\nname: %s\n%s\n",
newStream, fullName, err)
}
stream := append(oldStream, newStream...)
if len(stream) == 0 {
return nil
}
aggregated, err := b.AggregateBatch(stream)
if err != nil {
return err
}
dest := []redistream.Entry{{
Meta: &redistream.EntryMeta{Stream: b.BatchDest()},
Hash: map[string]interface{}{
"batch": aggregated,
"source": name,
},
}}
_, _, err = streamClient.Process(redistream.ProcessArgs{
From: stream, To: dest})
return err
}
func (b *Batcher) AggregateBatch(entries []redistream.Entry) (string, error) {
agg := []map[string]interface{}{}
for _, e := range entries {
agg = append(agg, e.Hash)
}
json, err := json.Marshal(agg)
if err != nil {
return "", err
}
return string(json), nil
}
|
package main
import (
"fmt"
"github.com/astaxie/beego/orm"
_ "github.com/go-sql-driver/mysql"
"time"
)
type User struct {
Id int `PK`
Name string `orm:"size(100)"`
Profile *Profile `orm:"rel(one)"` // OneToOne relation
Post []*Post `orm:"reverse(many)"` // 设置一对多的反向关系
}
type Userinfo struct {
Id int `PK` //如果表的主键不是id，那么需要加上pk注释，显式的说这个字段是主键
Username string
Departname string
Created time.Time
}
type Profile struct {
Id int
Age int16
User *User `orm:"reverse(one)"` // 设置一对一反向关系(可选)
}
type Post struct {
Id int
Title string
User *User `orm:"rel(fk)"` //设置一对多关系
Tags []*Tag `orm:"rel(m2m)"`
}
type Tag struct {
Id int
Name string
Posts []*Post `orm:"reverse(many)"`
}
func init() {
orm.Debug = true
orm.RegisterDataBase("default","mysql","root:root@tcp(localhost:3306)/beedbdemo?charset=utf8",30)
orm.SetMaxIdleConns("default",30)
orm.SetMaxOpenConns("default",100)
orm.RegisterModel(new(Userinfo),new(User), new(Profile), new(Tag),new(Post))
orm.RunSyncdb("default", false, true)
}
func main() {
o := orm.NewOrm()
profile := Profile{Age:35}
pid,err := o.Insert(&profile)
fmt.Println(pid,err)
user := User{Name:"bruce1299999",Profile:&profile}
id, err := o.Insert(&user)
fmt.Printf("ID:%d, ERR: %v\n",id ,err)
q_user := User{Id:3}
err = o.Read(&q_user)
if err == orm.ErrNoRows {
fmt.Println("查询不到!")
}
fmt.Println(err)
if err == nil{
fmt.Println(q_user)
fmt.Println(q_user.Id)
fmt.Println(q_user.Name)
q_user.Name = "bruce_update"
num,err := o.Update(&q_user)
if err == nil{
fmt.Println("num ",num)
}else{
fmt.Println("error ", err)
}
}
//var rs orm.RawSeter
sql := `
select *
from user
where id > 2
order by id desc
`
rs := o.Raw(sql)
var users []User
num,err :=rs.QueryRows(&users)
fmt.Println(num,err)
for _,f_user := range users {
fmt.Println(f_user.Id,f_user.Name)
}
//users := []User{
// {Name:"slene"},
// {Name:"bruce1"},
// {Name:"lily"},
//}
//successNums, err := o.InsertMulti(100,users)
//fmt.Println(successNums,err)
//user.Name = "bruce1"
//num, err := o.Update(&user)
//fmt.Printf("NUM: %d, ERR: %v\n", num, err)
//
//u := User{Id:user.Id}
//err = o.Read(&u)
//fmt.Printf("ERROR: %v\n",err)
//
//user.Name="bruce2"
//
//fmt.Println(u)
//fmt.Println("------")
//fmt.Println(user)
//num,err = o.Delete(&u)
//fmt.Printf("NUM: %d, ERR: %v\n", num, err)
}
|
package linkedlist
import (
"errors"
)
// ErrEmptyList is self explanitory
var ErrEmptyList = errors.New("Cannot Pop on an empty linked list")
// Node is a node element in our doubly linked list
type Node struct {
prevPtr *Node
Val interface{}
nextPtr *Node
}
// List is a doubly linked list
type List struct {
firstPtr *Node
lastPtr *Node
}
// First returns a pointer to the first element in the LL
func (ll *List) First() *Node {
return ll.firstPtr
}
// Last returns a pointer to the last element in the LL
func (ll *List) Last() *Node {
return ll.lastPtr
}
// Next returns a pointer to the next element
func (n *Node) Next() *Node {
return n.nextPtr
}
// Prev returns a pointer to the previous element
func (n *Node) Prev() *Node {
return n.prevPtr
}
// PushFront adds a new value to the beginning of the doubly linked list
func (ll *List) PushFront(arg interface{}) {
new := &Node{Val: arg, nextPtr: ll.First()}
first := ll.First()
if first != nil {
first.prevPtr = new
}
ll.firstPtr = new
if ll.lastPtr == nil {
ll.lastPtr = new
}
}
// PushBack finally resists the trappings of modern society
func (ll *List) PushBack(arg interface{}) {
new := &Node{Val: arg, prevPtr: ll.Last()}
last := ll.Last()
if last != nil {
last.nextPtr = new
}
ll.lastPtr = new
if ll.firstPtr == nil {
ll.firstPtr = new
}
}
// PopFront returns and removes the first value from the doubly linked list
func (ll *List) PopFront() (interface{}, error) {
first := ll.First()
if first == nil {
return 0, ErrEmptyList
}
newFirst := first.Next()
if newFirst != nil {
newFirst.prevPtr = nil
} else {
ll.lastPtr = nil
}
ll.firstPtr = newFirst
return first.Val, nil
}
// PopBack returns and removes the last value from the doubly linked list
func (ll *List) PopBack() (interface{}, error) {
last := ll.Last()
if last == nil {
return 0, ErrEmptyList
}
newLast := last.Prev()
if newLast != nil {
newLast.nextPtr = nil
} else {
ll.firstPtr = nil
}
ll.lastPtr = newLast
return last.Val, nil
}
// Reverse does what you think it does
func (ll *List) Reverse() {
var tmp, curr *Node
curr = ll.First()
ll.lastPtr = curr
for curr != nil {
tmp = curr.prevPtr
curr.prevPtr = curr.nextPtr
curr.nextPtr = tmp
curr = curr.prevPtr
}
if tmp != nil {
ll.firstPtr = tmp.prevPtr
}
}
// NewList creates a new *List from args
func NewList(input ...interface{}) *List {
ll := new(List)
for _, elem := range input {
ll.PushBack(elem)
}
return ll
}
|
package leetcode
type WordDictionary struct {
t []*WordDictionary
e bool
p bool
}
/** Initialize your data structure here. */
func Constructor() WordDictionary {
var dic = WordDictionary{t: make([]*WordDictionary, 26), e: false, p: false}
return dic
}
/** Inserts a word into the dict. */
func (this *WordDictionary) AddWord(word string) {
if len(word) == 0 {
this.e = true
return
}
c := word[0] - 'a'
if this.t[c] == nil {
tmp := Constructor()
this.t[c] = &tmp
}
this.t[c].p = true
this.t[c].AddWord(word[1:])
}
/** Returns if the word is in the dict. */
func (this *WordDictionary) Search(word string) bool {
if len(word) == 0 {
return this.e
}
if word[0] != '.' {
c := word[0] - 'a'
if this.t[c] != nil {
return this.t[c].Search(word[1:])
}
return false
} else {
ret := false
for i := 0; i < 26; i++ {
if this.t[i] != nil {
ret = ret || this.t[i].Search(word[1:])
}
if ret {
return ret
}
}
return ret
}
}
|
// Copyright (c) 2015-2016 The btcsuite developers
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
package rpcserver
import (
"os"
"strings"
"google.golang.org/grpc/grpclog"
"github.com/btcsuite/btclog"
)
// UseLogger sets the logger to use for the gRPC server.
func UseLogger(l btclog.Logger) {
grpclog.SetLogger(logger{l}) // nolint:staticcheck
}
// logger uses a btclog.Logger to implement the grpclog.Logger interface.
type logger struct {
btclog.Logger
}
// stripGrpcPrefix removes the package prefix for all logs made to the grpc
// logger, since these are already included as the btclog subsystem name.
func stripGrpcPrefix(logstr string) string {
return strings.TrimPrefix(logstr, "grpc: ")
}
// stripGrpcPrefixArgs removes the package prefix from the first argument, if it
// exists and is a string, returning the same arg slice after reassigning the
// first arg.
func stripGrpcPrefixArgs(args ...interface{}) []interface{} {
if len(args) == 0 {
return args
}
firstArgStr, ok := args[0].(string)
if ok {
args[0] = stripGrpcPrefix(firstArgStr)
}
return args
}
func (l logger) Fatal(args ...interface{}) {
l.Critical(stripGrpcPrefixArgs(args)...)
os.Exit(1)
}
func (l logger) Fatalf(format string, args ...interface{}) {
l.Criticalf(stripGrpcPrefix(format), args...)
os.Exit(1)
}
func (l logger) Fatalln(args ...interface{}) {
l.Critical(stripGrpcPrefixArgs(args)...)
os.Exit(1)
}
func (l logger) Print(args ...interface{}) {
l.Info(stripGrpcPrefixArgs(args)...)
}
func (l logger) Printf(format string, args ...interface{}) {
l.Infof(stripGrpcPrefix(format), args...)
}
func (l logger) Println(args ...interface{}) {
l.Info(stripGrpcPrefixArgs(args)...)
}
|
package transformer
import (
"testing"
rpb "github.com/ampproject/amppackager/transformer/request"
)
func TestValidateRequest(t *testing.T) {
tests := []struct {
rs []*rpb.VersionRange
expectedError bool
}{
{
rs: nil,
expectedError: false,
},
{
rs: []*rpb.VersionRange{},
expectedError: false,
},
{
rs: []*rpb.VersionRange{{Max: 1, Min: 2}},
expectedError: true, // Malformed.
},
{
rs: []*rpb.VersionRange{{Max: 1, Min: -1}},
expectedError: true, // Negative.
},
{
rs: []*rpb.VersionRange{{Max: 1, Min: 1}},
expectedError: false,
},
{
rs: []*rpb.VersionRange{{Max: 2, Min: 1}, {Max: 1, Min: 1}},
expectedError: true, // Overlapping.
},
{
rs: []*rpb.VersionRange{{Max: 3, Min: 2}, {Max: 1, Min: 1}},
expectedError: false,
},
{
rs: []*rpb.VersionRange{{Max: 1, Min: 1}, {Max: 3, Min: 2}},
expectedError: true, // Out of order.
},
}
for _, test := range tests {
err := validateRequest(test.rs)
if test.expectedError != (err != nil) {
t.Errorf("validateRequest(%+v) unexpected err = %v", test.rs, err)
}
}
}
func TestSelectVersion(t *testing.T) {
tests := []struct {
requested, supported []*rpb.VersionRange
expectedVersion int64
expectedError bool
}{
// No supported.
{
requested: []*rpb.VersionRange{{Max: 4, Min: 1}},
supported: []*rpb.VersionRange{},
expectedError: true,
},
// No request, highest version supported.
{
requested: []*rpb.VersionRange{},
supported: []*rpb.VersionRange{{Max: 4, Min: 1}},
expectedVersion: 4,
},
// No request (nil), highest version supported.
{
requested: nil,
supported: []*rpb.VersionRange{{Max: 4, Min: 1}},
expectedVersion: 4,
},
// One version, match.
{
requested: []*rpb.VersionRange{{Max: 1, Min: 1}},
supported: []*rpb.VersionRange{{Max: 1, Min: 1}},
expectedVersion: 1,
},
// One version, mismatch.
{
requested: []*rpb.VersionRange{{Max: 1, Min: 1}},
supported: []*rpb.VersionRange{{Max: 2, Min: 2}},
expectedError: true,
},
// Supported is a subset of requested.
{
requested: []*rpb.VersionRange{{Max: 4, Min: 1}},
supported: []*rpb.VersionRange{{Max: 2, Min: 2}},
expectedVersion: 2,
},
// Requested is a subset of supported.
{
requested: []*rpb.VersionRange{{Max: 2, Min: 2}},
supported: []*rpb.VersionRange{{Max: 4, Min: 1}},
expectedVersion: 2,
},
// Requested and supported abut.
{
requested: []*rpb.VersionRange{{Max: 4, Min: 2}},
supported: []*rpb.VersionRange{{Max: 2, Min: 1}},
expectedVersion: 2,
},
// Requested includes a hole in supported.
{
requested: []*rpb.VersionRange{{Max: 2, Min: 1}},
supported: []*rpb.VersionRange{{Max: 4, Min: 3}, {Max: 1, Min: 1}},
expectedVersion: 1,
},
// Requested requires a hole in supported.
{
requested: []*rpb.VersionRange{{Max: 2, Min: 2}},
supported: []*rpb.VersionRange{{Max: 4, Min: 3}, {Max: 1, Min: 1}},
expectedError: true,
},
// Overlap is between the second elements of both requested and supported.
{
requested: []*rpb.VersionRange{{Max: 6, Min: 5}, {Max: 2, Min: 1}},
supported: []*rpb.VersionRange{{Max: 4, Min: 3}, {Max: 1, Min: 1}},
expectedVersion: 1,
},
}
for _, test := range tests {
v, err := selectVersion(test.requested, test.supported)
if test.expectedError {
if err == nil {
t.Errorf("selectVersion(%+v, %+v), want err, got v = %d", test.requested, test.supported, v)
}
} else if err != nil {
t.Errorf("selectVersion(%+v, %+v), want v = %d, got err = %v", test.requested, test.supported, test.expectedVersion, err)
} else if v != test.expectedVersion {
t.Errorf("selectVersion(%+v, %+v), want v = %d, got v = %v", test.requested, test.supported, test.expectedVersion, v)
}
}
}
|
package composite
import (
"github.com/stretchr/testify/assert"
"testing"
)
func Test(t *testing.T) {
directory := directory{path: "directoryPath"}
var file1 file = &concreteFile{path: "path1", size: 20.5}
var file2 file = &concreteFile{path: "path2", size: 10.425}
var file3 file = &concreteFile{path: "path3", size: 1.721}
var file4 file = &concreteFile{path: "path4", size: 0.5}
directory.addFile(file1)
directory.addFile(file2)
directory.addFile(file3)
directory.addFile(file4)
assert.Equal(t, 4, directory.files.Len())
assert.Equal(t, file1.Size()+file2.Size()+file3.Size()+file4.Size(), directory.Size())
directory.deleteFile(file3)
directory.deleteFile(file4)
assert.Equal(t, 2, directory.files.Len())
assert.Equal(t, file1.Size()+file2.Size(), directory.Size())
}
|
package main
import (
"encoding/json"
"io/ioutil"
"log"
)
type Perms map[string]bool
type user struct {
// export your fields to encode them
FirstName string `json:"first_name"`
Password string `json:"-"`
Perms `json:"perms,omitempty"`
}
func main() {
users := []user{
{
FirstName: "Diwakar",
Password: "abc123",
Perms: Perms{"admin": true},
},
{
FirstName: "Rahul",
Password: "xyz",
},
{
FirstName: "Ravi",
Password: "qwerty",
Perms: Perms{"write": false},
},
}
//jsonData, err := json.Marshal(users)
jsonData, err := json.MarshalIndent(users, "", "\t")
if err != nil {
log.Println(err)
return
}
err = ioutil.WriteFile("user.json", jsonData, 666)
if err != nil {
log.Println(err)
return
}
}
|
package remotev
import (
"fmt"
"golang.org/x/crypto/ssh"
"log"
"net"
// "os"
"strings"
"time"
)
func connect(user, password, host string, port int) (*ssh.Session, error) {
var (
auth []ssh.AuthMethod
addr string
clientConfig *ssh.ClientConfig
client *ssh.Client
session *ssh.Session
err error
)
// get auth method
auth = make([]ssh.AuthMethod, 0)
auth = append(auth, ssh.Password(password))
clientConfig = &ssh.ClientConfig{
User: user,
Auth: auth,
Timeout: 30 * time.Second,
HostKeyCallback: func(hostname string, remote net.Addr, key ssh.PublicKey) error {
return nil
},
}
// connet to ssh
addr = fmt.Sprintf("%s:%d", host, port)
if client, err = ssh.Dial("tcp", addr, clientConfig); err != nil {
return nil, err
}
// create session
if session, err = client.NewSession(); err != nil {
return nil, err
}
return session, nil
}
func GetVersionMaps(name, pw, addr string) (map[string]string, error) {
// session, err := connect("root", "xungejiaoyu2015", "10.1.41.60", 22)
session, err := connect(name, pw, addr, 22)
if err != nil {
log.Fatal(err)
return nil, err
}
defer session.Close()
// session.Stderr = os.Stderr
cmd := "docker ps | awk '{print $2}' | grep -v ID"
res, err := session.Output(cmd)
if err != nil {
fmt.Println(err)
return nil, err
}
s := string(res)
// fmt.Println(strings.Split(s, "5000/"))
version := make(map[string]string)
for _, value := range strings.Split(s, "\n") {
if value != "" {
s := strings.Split(value, "5000/")
// fmt.Println(strings.Split(value, "5000/"))
s1 := strings.Split(s[1], "/")
// fmt.Println(s1)
s2 := strings.Split(s1[1], ":")
// fmt.Println(s2)
version[s2[0]] = s2[1]
}
}
fmt.Println(version)
return version, nil
}
|
package medasync
func (c *Config) CopyFrom(other *Config) {
c.SynchronisationChunkSize = other.SynchronisationChunkSize
c.Inserter.CopyFrom(&other.Inserter)
c.Subpath = other.Subpath
c.TemporaryDirectory = other.TemporaryDirectory
c.GlobalWorkDirectory = other.GlobalWorkDirectory
c.NodeList = other.NodeList
c.ExcludePathPatterns = other.ExcludePathPatterns
c.SnapshotName = other.SnapshotName
c.RunID = other.RunID
c.SyncMode = other.SyncMode
c.DB = other.DB
c.FileSystem = other.FileSystem
c.Logger = other.Logger
}
func (c *Config) Merge(other *Config) *Config {
if other.SynchronisationChunkSize != 0 {
c.SynchronisationChunkSize = other.SynchronisationChunkSize
}
c.Inserter.Merge(&other.Inserter)
if len(other.Subpath) > 0 {
c.Subpath = other.Subpath
}
if len(other.TemporaryDirectory) > 0 {
c.TemporaryDirectory = other.TemporaryDirectory
}
if len(other.GlobalWorkDirectory) > 0 {
c.GlobalWorkDirectory = other.GlobalWorkDirectory
}
if len(other.NodeList) > 0 {
c.NodeList = other.NodeList
}
if len(other.ExcludePathPatterns) > 0 {
c.ExcludePathPatterns = other.ExcludePathPatterns
}
if len(other.SnapshotName) > 0 {
c.SnapshotName = other.SnapshotName
}
if other.RunID != 0 {
c.RunID = other.RunID
}
if other.SyncMode != 0 {
c.SyncMode = other.SyncMode
}
if other.DB != nil {
c.DB = other.DB
}
if other.FileSystem != nil {
c.FileSystem = other.FileSystem
}
if other.Logger != nil {
c.Logger = other.Logger
}
return c
}
func (c *Config) Clone() *Config {
config := &Config{}
config.CopyFrom(c)
return config
}
|
package main
import (
"encoding/csv"
"flag"
"fmt"
"io"
"net/url"
"os"
"strconv"
"strings"
"time"
"github.com/ChimeraCoder/anaconda"
)
var (
consumerKey = flag.String("consumer_key", "", "Issued from Twitter. ")
consumerSecret = flag.String("consumer_secret", "", "Issued from Twitter. ")
accessToken = flag.String("access_token", "", "Issued from Twitter. ")
accessTokenSecret = flag.String("access_token_secret", "", "Issued from Twitter. ")
user = flag.String("user", "none", "The account of user. ")
friendsPath = flag.String("friends_path", "/tmp", "The path of the lists of user's friends. ")
accountsPath = flag.String("accounts_path", "/tmp", "The path of the lists of accounts. ")
tweetsPath = flag.String("tweets_path", "/tmp", "The path of the lists of tweets. ")
// hashTag = flag.String("hash_tag", "", "The name of hash tag.")
)
func getTwitterAPI() *anaconda.TwitterApi {
anaconda.SetConsumerKey(*consumerKey)
anaconda.SetConsumerSecret(*consumerSecret)
return anaconda.NewTwitterApi(*accessToken, *accessTokenSecret)
}
func getUserTimeline(api *anaconda.TwitterApi, scname string, count int) []anaconda.Tweet {
var tweets = make([]anaconda.Tweet, 0, 10)
curID := "-1"
perCount := 200
sCount := strconv.Itoa(perCount)
for {
start := time.Now()
v := url.Values{}
v.Set("screen_name", scname)
v.Set("count", sCount)
v.Set("exclude_replies", "true")
v.Set("include_rts", "false")
if curID != "-1" {
v.Set("max_id", curID)
}
tws, _ := api.GetUserTimeline(v)
tweets = append(tweets, tws...)
if (len(tws) == 0) || (len(tweets) >= count) {
break
}
curID = tws[len(tws)-1].IdStr
end := time.Now()
d := end.Sub(start).Nanoseconds()
wait := 1*1000*1000*1000 - d + (1 * 1000 * 1000)
time.Sleep(time.Duration(wait))
}
return tweets
}
func writeFriends(api *anaconda.TwitterApi, scname string, path string) error {
file, err := os.Create(path)
if err != nil {
return nil
}
defer file.Close()
file.Write(([]byte)("screen_name,name,url\n"))
start := time.Now()
ncur := "-1"
for {
v := url.Values{}
v.Set("screen_name", scname)
v.Set("count", "60")
v.Set("cursor", ncur)
cursor, _ := api.GetFriendsList(v)
for _, user := range cursor.Users {
ts := getUserTimeline(api, user.ScreenName, 20)
lt6m := isLessThan6Mionth(ts, start)
isPR := (strings.Index(user.Name, "公式") > -1) || (strings.Index(user.ScreenName, "official") > -1)
url := fmt.Sprintf("https://twitter.com/%s", user.ScreenName)
fmt.Printf("user=%s, protected=%v, last6mon=%v, isPR=%v \n", user.ScreenName, user.Protected, lt6m, isPR)
if lt6m && !isPR {
file.Write(([]byte)(fmt.Sprintf("%s,\"%s\",%s\n", user.ScreenName, user.Name, url)))
}
}
ncur = cursor.Next_cursor_str
fmt.Printf("next: %s\n", ncur)
if cursor.Next_cursor == 0 {
break
}
}
end := time.Now()
fmt.Println("writeFriends")
fmt.Printf("%f秒\n", (end.Sub(start)).Seconds())
return nil
}
func isLessThan6Mionth(tweets []anaconda.Tweet, now time.Time) bool {
lt6m := false
if len(tweets) > 0 {
if t, err := tweets[0].CreatedAtTime(); err == nil {
if now.Sub(t).Hours() < 24*30*6 {
lt6m = true
} else {
lt6m = false
}
}
}
return lt6m
}
const (
ScreenName = 0
Name = 1
URL = 2
Sex = 3
IsEngineer = 4
)
func writeTweetsByAccountList(api *anaconda.TwitterApi, inPath string, outPath string) error {
out, err := os.Create(outPath)
if err != nil {
return nil
}
defer out.Close()
header := []string{"tweet", "screen_name", "sex", "is_engineer", "url_type"}
in, err := os.Open(inPath)
if err != nil {
return nil
}
defer in.Close()
reader := csv.NewReader(in)
reader.LazyQuotes = true
writer := csv.NewWriter(out)
writer.Write(header)
line := -1
for {
cols, err := reader.Read()
if err == io.EOF {
break
}
if err != nil {
return err
}
line++
if line == 0 { // ヘッダー行
continue
}
fmt.Printf("%s \n", cols[ScreenName])
twts := getUserTimeline(api, cols[ScreenName], 400)
for _, t := range twts {
urlType := getUrlType(t)
if urlType != "external" {
writer.Write([]string{convNewline(t.FullText, ","), cols[ScreenName], cols[Sex], cols[IsEngineer], urlType})
}
}
}
return nil
}
func getUrlType(t anaconda.Tweet) string {
for _, u := range t.Entities.Urls {
if (u.Expanded_url != "") && (strings.Index(u.Expanded_url, "https://twitter.com") < 0) {
return "external"
}
}
urlType := ""
for _, m := range t.Entities.Media {
urlType = m.Type
}
return urlType
}
func convNewline(str, nlcode string) string {
return strings.NewReplacer(
"\r\n", nlcode,
"\r", nlcode,
"\n", nlcode,
).Replace(str)
}
func main() {
flag.Parse()
api := getTwitterAPI()
// if err := writeFriends(api, *user, *friendsPath); err != nil {
// fmt.Errorf("[writeFriends] error occured: %v", err)
// }
if err := writeTweetsByAccountList(api, *accountsPath, *tweetsPath); err != nil {
fmt.Errorf("[writeTweetsByAccountList] error occured: %v", err)
}
}
|
package security
import (
"encoding/json"
"time"
)
type KeyValue struct {
Key string
Value string
}
type ConnectorFunction func(AccessManager, *ScheduledConnector, Session) error
type ConnectorInfo struct {
SystemType string // Moodle, GoogleSheets, Formsite
SystemIcon string
DataType string // Subject, Student, Course, etc...
Name string
Description string // Description of the purpose of this connector
Label string
Direction int
Config [][]string
ExternalSystemPicker bool
Run func(AccessManager, *ScheduledConnector, Session) error
}
type ScheduledConnector struct {
Uuid string `json:",omitempty"`
ExternalSystemUuid string `json:",omitempty"`
Label string `json:",omitempty"`
Config []*KeyValue `json:",omitempty"`
Data []*KeyValue `json:",omitempty"`
Frequency string `json:",omitempty"` // daily, hourly, weekly
Hour int `json:",omitempty"` // if hourly/weekly, what hour
Day int `json:",omitempty"` // if weekly, what day
LastRun *time.Time `json:",omitempty"`
// Describes the configuration of this connector. i.e. Where do we connect to? What server? What domain? etc...
Description string `json:",omitempty"`
Disabled bool
}
func (sc *ScheduledConnector) GetConfig(key string) string {
key = Underscorify(key)
for _, k := range sc.Config {
if key == Underscorify(k.Key) {
return k.Value
}
}
return ""
}
func (s *ScheduledConnector) String() string {
b, err := json.Marshal(s)
if err != nil {
panic(err)
}
return string(b)
}
// SetConfig adds, updates, or removes a config setting.
func (sc *ScheduledConnector) SetConfig(key, value string) {
ukey := Underscorify(key)
if value == "" {
del := -1
for i, k := range sc.Config {
if ukey == Underscorify(k.Key) {
del = i
break
}
}
if del >= 0 {
sc.Config = append(sc.Config[:del], sc.Config[del+1:]...)
}
return
}
for _, k := range sc.Config {
if ukey == Underscorify(k.Key) {
k.Value = value
return
}
}
sc.Config = append(sc.Config, &KeyValue{key, value})
}
func (sc *ScheduledConnector) GetData(key string) string {
key = Underscorify(key)
for _, k := range sc.Data {
if key == Underscorify(k.Key) {
return k.Value
}
}
return ""
}
func (sc *ScheduledConnector) SetData(key, value string) {
ukey := Underscorify(key)
if value == "" {
del := -1
for i, k := range sc.Data {
if ukey == Underscorify(k.Key) {
del = i
break
}
}
if del >= 0 {
sc.Data = append(sc.Data[:del], sc.Data[del+1:]...)
}
return
}
for _, k := range sc.Data {
if ukey == Underscorify(k.Key) {
k.Value = value
return
}
}
sc.Data = append(sc.Data, &KeyValue{key, value})
}
|
package handler
import (
"net/url"
"testing"
"github.com/stretchr/testify/assert"
)
func TestSanitizeQueryParamOf(t *testing.T) {
tcs := []struct{
qps url.Values
key string
defVal string
expected string
}{
{url.Values{}, "key", "3", "3"},
{url.Values{"key":[]string{}}, "key", "3", "3"},
{url.Values{"key2":[]string{"1","2"}}, "key", "10", "10"},
{url.Values{"key":[]string{"2"}}, "key", "5", "2"},
{url.Values{"key":[]string{"2"}}, "key", "2", "2"},
{url.Values{"key":[]string{"2","3"}}, "key", "3", "2"},
{url.Values{"key":[]string{"2"}, "key2":[]string{"5"}}, "key2", "2", "5"},
}
for _, tc := range tcs {
actual := sanitizeQueryParamOf(tc.qps, tc.key, tc.defVal)
assert.Equal(t, tc.expected, actual)
}
} |
/*
Copyright 2019 IBM Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main
import (
"encoding/json"
"net/http"
"io"
"io/ioutil"
"k8s.io/klog"
"github.com/google/go-github/github"
"os"
// "golang.org/x/oauth2"
"context"
"fmt"
"strings"
)
const (
tlsCertPath = "/etc/tls/tls.crt"
tlsKeyPath = "/etc/tls/tls.key"
)
/* HTTP listsnert */
func listenerHandler(writer http.ResponseWriter, req *http.Request) {
header := req.Header
klog.Infof("Recevied request. Header: %v", header)
var body io.ReadCloser = req.Body
defer body.Close()
bytes, err := ioutil.ReadAll(body)
if err != nil {
klog.Errorf("Webhook listener can not read body. Error: %v", err);
} else {
klog.Infof("Webhook listener received body: %v", string(bytes))
}
var bodyMap map[string]interface{}
err = json.Unmarshal(bytes, &bodyMap)
if err != nil {
klog.Errorf("Unable to unarmshal json body: %v", err)
return
}
message := make(map[string]interface{})
message[HEADER] = map[string][]string(header)
message[BODY] = bodyMap
bytes, err = json.Marshal(message)
if err != nil {
klog.Errorf("Unable to marshall as JSON: %v, type %T", message, message)
return
}
destNode := eventProviders.GetEventDestination(WEBHOOKDESTINATION)
if destNode == nil {
klog.Errorf("Unable to find an eventDestination with the name '%s'. Verify that it has been defined.", WEBHOOKDESTINATION)
return
}
provider := eventProviders.GetMessageProvider(destNode.ProviderRef)
if provider == nil {
klog.Errorf("Unable to find a messageProvider with the name '%s'. Verify that is has been defined.", destNode.ProviderRef)
return
}
err = provider.Send(destNode, bytes, nil)
if err != nil {
klog.Errorf("Unable to send webhook message. Error: %v", err)
return
}
if err != nil {
klog.Errorf("Error processing webhook message: %v", err)
}
}
func newListener() error{
http.HandleFunc("/webhook", listenerHandler)
if disableTLS {
klog.Infof("Starting listener on port 9080");
err := http.ListenAndServe(":9080", nil)
return err
}
// Setup TLS listener
if _, err := os.Stat(tlsCertPath); os.IsNotExist(err) {
klog.Fatalf("TLS certificate '%s' not found: %v", tlsCertPath, err)
return err
}
if _, err := os.Stat(tlsKeyPath); os.IsNotExist(err) {
klog.Fatalf("TLS private key '%s' not found: %v", tlsKeyPath, err)
return err
}
klog.Infof("Starting listener on port 9443");
err := http.ListenAndServeTLS(":9443", tlsCertPath, tlsKeyPath, nil)
return err
}
/* Get the repository's information from from github message body: name, owner, html_url, and ref */
func getRepositoryInfo(body map[string]interface{}, repositoryEvent string) (string, string, string, string, error) {
ref := ""
if repositoryEvent == "push" {
// use SHA for ref
afterObj, ok := body["after"]
if !ok {
return "", "", "", "", fmt.Errorf("Unable to find after for push webhook message")
}
ref, ok = afterObj.(string)
if !ok {
return "", "", "", "", fmt.Errorf("after for push webhook message (%s) is not a string but %T", afterObj, afterObj)
}
} else if repositoryEvent == "pull_request" {
// use pull_request.head.sha
prObj, ok := body["pull_request"]
if !ok {
return "", "", "", "", fmt.Errorf("Unable to find pull_request in webhook message")
}
prMap, ok := prObj.(map[string]interface{})
if !ok {
return "", "", "", "", fmt.Errorf("pull_request in webhook message is of type %T, not map[string]interface{}", prObj)
}
headObj, ok := prMap["head"]
if !ok {
return "", "", "", "", fmt.Errorf("pull_request in webhook message does not contain head")
}
head, ok := headObj.(map[string]interface{})
if !ok {
return "", "", "", "", fmt.Errorf("pull_request head not map[string]interface{}, but is %T", headObj)
}
shaObj, ok := head["sha"]
if !ok {
return "", "", "", "", fmt.Errorf("pull_request.head.sha not found")
}
ref, ok = shaObj.(string)
if !ok {
return "", "", "", "", fmt.Errorf("pull_request merge_commit_sha in webhook message not a string: %v", shaObj)
}
}
repositoryObj, ok := body["repository"]
if !ok {
return "", "", "", "", fmt.Errorf("Unable to find repository in webhook message")
}
repository, ok := repositoryObj.(map[string]interface{})
if !ok {
return "", "", "", "", fmt.Errorf("webhook message repository object not map[string]interface{}: %v", repositoryObj)
}
nameObj, ok := repository["name"]
if !ok {
return "", "", "", "", fmt.Errorf("webhook message repository name not found")
}
name, ok := nameObj.(string)
if !ok {
return "", "", "", "", fmt.Errorf("webhook message repository name not a string: %v", nameObj)
}
ownerMapObj, ok := repository["owner"]
if !ok {
return "", "", "", "", fmt.Errorf("webhook message repository owner not found")
}
ownerMap, ok := ownerMapObj.(map[string]interface{})
if !ok {
return "", "", "", "", fmt.Errorf("webhook message repository owner object not map[string]interface{}: %v", ownerMapObj)
}
ownerObj, ok := ownerMap["login"]
if !ok {
return "", "", "", "", fmt.Errorf("webhook message repository owner login not found")
}
owner, ok := ownerObj.(string)
if !ok {
return "", "", "", "", fmt.Errorf("webhook message repository owner login not string : %v", ownerObj)
}
htmlURLObj, ok := repository["html_url"]
if !ok {
return "", "", "", "", fmt.Errorf("webhook message repository html_url not found")
}
htmlURL, ok := htmlURLObj.(string)
if !ok {
return "", "", "", "", fmt.Errorf("webhook message html_url not string: %v", htmlURL)
}
return owner, name, htmlURL, ref, nil
}
/*
func testGithubEnterprise() error {
prefix, collection, version, err := downloadAppsodyConfig("kabanero-org-test", "test1", "https://github.ibm.com", "w3id", "token", true)
if err != nil {
return err
}
fmt.Printf("prefix: %s, collection: %s, version: %s\n", prefix, collection, version)
return nil
}
*/
/* Download .appsody-cofig.yaml and return: prefix, collection, version, true if file exists, and error
for example: stack: kabanero/nodejs-express:0.2
prefix: kabanero
collection: nodejs-express
version: 0.2
*/
func downloadAppsodyConfig(owner, repository, githubURL, ref, user, token string, isEnterprise bool) (string, string, string, bool, error) {
buf, exists, err := downloadFileFromGithub(owner, repository,".appsody-config.yaml", ref, githubURL, user, token, isEnterprise)
if err != nil {
return "", "", "", exists, err
}
if !exists {
return "", "", "", exists, nil
}
/* look in the yaml for: stack: kabanero/nodejs-express:0.2 */
appsodyConfigMap, err := yamlToMap(buf);
if err != nil {
return "", "", "", true, err
}
stack, ok := appsodyConfigMap["stack"]
if !ok {
return "", "", "", true, fmt.Errorf(".appsody-config.yaml does not contain stack")
}
stackStr, ok := stack.(string)
if !ok {
return "", "", "", true, fmt.Errorf(".appsody-config.yaml stack: %s is not a string", stack)
}
components := strings.Split(stackStr, ":")
if len(components) == 2 {
prefixName := strings.Trim(components[0], " ")
prefixNameArray := strings.Split(prefixName, "/")
if len(prefixNameArray) == 2 {
return prefixNameArray[0], prefixNameArray[1], components[1], true, nil
}
}
return "", "", "", true, fmt.Errorf(".appsody-config.yaml contains %v. It is not of the format stacK: prefix/name:version", stackStr)
}
/* Download file and return: bytes of the file, true if file texists, and any error
*/
func downloadFileFromGithub(owner, repository,fileName, ref, githubURL, user, token string, isEnterprise bool) ([]byte, bool, error) {
if klog.V(5){
klog.Infof("downloadFileFromGithub %v, %v, %v, %v, %v, %v, %v", owner, repository, fileName, ref, githubURL, user, isEnterprise)
}
context := context.Background()
tp := github.BasicAuthTransport{
Username: user,
Password: token,
}
/*
tokenService := oauth2.StaticTokenSource(
&oauth2.Token{AccessToken: token},
)
tokenClient := oauth2.NewClient(context, tokenService)
*/
var err error
var client *github.Client
if isEnterprise {
githubURL = githubURL + "/api/v3"
client, err = github.NewEnterpriseClient(githubURL, githubURL, tp.Client())
if err != nil {
return nil, false, err
}
} else {
client = github.NewClient(tp.Client())
}
var options *github.RepositoryContentGetOptions = nil
if ref != "" {
options = &github.RepositoryContentGetOptions{ ref }
}
/*
rc, err := client.Repositories.DownloadContents(context, owner, repository, fileName, options)
if err != nil {
fmt.Printf("Error type: %T, value: %v\n", err, err)
return nil, false, err
}
defer rc.Close()
buf, err := ioutil.ReadAll(rc)
*/
fileContent, _, resp, err := client.Repositories.GetContents(context, owner, repository, fileName, options)
if resp.Response.StatusCode == 200 {
if fileContent != nil {
if fileContent.Content == nil {
return nil, true, fmt.Errorf("Content for %v/%v/%v is nil" , owner, repository, fileName)
}
content, err := fileContent.GetContent()
if err != nil {
klog.Infof("download File Form Github error %v", err)
} else {
klog.Infof("download File from Github: buffer %v", content)
}
return []byte(content), true, err
}
/* some other errors */
return nil, false, fmt.Errorf("unable to download %v/%v/%v: not a file" , owner, repository, fileName)
} else if resp.Response.StatusCode == 400 {
/* does not exist */
return nil, false, nil
} else {
/* some other errors */
return nil, false, fmt.Errorf("unable to download %v/%v/%v, http error %v", owner, repository, fileName, resp.Response.Status)
}
}
/* Download YAML from Repository.
header: HTTP header from webhook
bodyMap: HTTP message body from webhook
*/
func downloadYAML(header map[string][]string, bodyMap map[string]interface{}, fileName string ) (map[string]interface{}, bool, error) {
hostHeader, isEnterprise := header[http.CanonicalHeaderKey("x-github-enterprise-host")]
var host string
if !isEnterprise {
host = "github.com"
} else {
host = hostHeader[0]
}
repositoryEvent := header["X-Github-Event"][0]
owner, name, htmlURL, ref, err := getRepositoryInfo(bodyMap, repositoryEvent)
if err != nil {
return nil, false, fmt.Errorf("Unable to get repository owner, name, or html_url from webhook message: %v", err);
}
user, token , _, err := getURLAPIToken(dynamicClient, webhookNamespace, htmlURL )
if err != nil {
return nil, false, fmt.Errorf("Unable to get user/token secrets for URL %v", htmlURL);
}
githubURL := "https://" + host
bytes, found, err := downloadFileFromGithub(owner, name, fileName, ref, githubURL, user, token, isEnterprise)
if err != nil {
return nil, found, err
}
retMap, err := yamlToMap(bytes);
return retMap, found, err
}
|
// Copyright 2020 The Reed Developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
package discover
import (
"net"
)
type udpListener struct {
conn *net.UDPConn
}
func NewUDPListener(ip net.IP, port uint16) (*udpListener, error) {
listener := &udpListener{}
c, err := net.ListenUDP("udp", &net.UDPAddr{IP: ip, Port: int(port)})
if err != nil {
return nil, err
}
listener.conn = c
return listener, nil
}
|
package annotation_test
import (
"bytes"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"testing"
"time"
"github.com/m-lab/etl/annotation"
)
var epoch time.Time = time.Unix(0, 0)
func TestFetchGeoAnnotations(t *testing.T) {
tests := []struct {
ips []string
timestamp time.Time
geoDest []*annotation.GeolocationIP
res []*annotation.GeolocationIP
}{
{
ips: []string{},
timestamp: epoch,
geoDest: []*annotation.GeolocationIP{},
res: []*annotation.GeolocationIP{},
},
{
ips: []string{"", "127.0.0.1", "2.2.2.2"},
timestamp: epoch,
geoDest: []*annotation.GeolocationIP{
&annotation.GeolocationIP{},
&annotation.GeolocationIP{},
&annotation.GeolocationIP{},
},
res: []*annotation.GeolocationIP{
&annotation.GeolocationIP{},
&annotation.GeolocationIP{Postal_code: "10583"},
&annotation.GeolocationIP{},
},
},
}
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, `{"127.0.0.10" : {"Geo":{"postal_code":"10583"},"ASN":{}}`+
`,"2.2.2.20" : {"Geo":null,"ASN":null}}`)
}))
for _, test := range tests {
annotation.BatchURL = ts.URL
annotation.FetchGeoAnnotations(test.ips, test.timestamp, test.geoDest)
if !reflect.DeepEqual(test.geoDest, test.res) {
t.Errorf("Expected %s, got %s", test.res, test.geoDest)
}
}
}
func TestGetAndInsertGeolocationIPStruct(t *testing.T) {
tests := []struct {
geo *annotation.GeolocationIP
ip string
timestamp time.Time
url string
res *annotation.GeolocationIP
}{
{
geo: &annotation.GeolocationIP{},
ip: "123.123.123.001",
timestamp: time.Now(),
url: "portGarbage",
res: &annotation.GeolocationIP{},
},
{
geo: &annotation.GeolocationIP{},
ip: "127.0.0.1",
url: "/10583",
res: &annotation.GeolocationIP{Postal_code: "10583"},
},
}
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, `{"Geo":{"postal_code":"10583"},"ASN":{}}`)
}))
for _, test := range tests {
annotation.BaseURL = ts.URL + test.url
annotation.GetAndInsertGeolocationIPStruct(test.geo, test.ip, test.timestamp)
if !reflect.DeepEqual(test.geo, test.res) {
t.Errorf("Expected %v, got %v for test %s", test.res, test.geo, test.url)
}
}
}
func TestGetGeoData(t *testing.T) {
tests := []struct {
url string
res *annotation.GeoData
}{
{
url: "portGarbage",
res: nil,
},
{
url: "/badJson",
res: nil,
},
{
url: "/goodJson",
res: &annotation.GeoData{},
},
}
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
path := r.URL.Path
if strings.HasSuffix(path, "goodJson") {
fmt.Fprint(w, `{"Geo":null,"ASN":null}`)
return
}
fmt.Fprint(w, "{jngngfsljngsljngfsljngsljn")
}))
for _, test := range tests {
res := annotation.GetGeoData(ts.URL + test.url)
if res != test.res && *res != *test.res {
t.Errorf("Expected %+v, got %+v for data: %s\n", test.res, res, test.url)
}
}
}
func TestQueryAnnotationService(t *testing.T) {
tests := []struct {
url string
res []byte
err error
}{
{
url: "portGarbage",
res: nil,
err: errors.New("HTTP Protocol Error"),
},
{
url: "/error",
res: nil,
err: errors.New("HTTP 404 Error"),
},
{
url: "/Echo",
res: []byte("Echo"),
err: nil,
},
}
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
path := r.URL.Path
if strings.HasSuffix(path, "error") {
http.Error(w, "Test Error", 404)
return
}
fmt.Fprint(w, "Echo")
}))
for _, test := range tests {
json, err := annotation.QueryAnnotationService(ts.URL + test.url)
if err != nil && test.err == nil || err == nil && test.err != nil {
t.Errorf("Expected %s, got %s, for %s", test.err, err, test.url)
}
if !bytes.Equal(json, test.res) {
t.Errorf("Expected %s, got %s, for %s", string(test.res), string(json), test.url)
}
}
}
func TestParseJSONGeoDataResponse(t *testing.T) {
tests := []struct {
testBuffer []byte
resultData *annotation.GeoData
resultError error
}{
{
testBuffer: []byte(`{"Geo":null,"ASN":null}`),
resultData: &annotation.GeoData{Geo: nil, ASN: nil},
resultError: nil,
},
{
testBuffer: []byte(`"Geo":{},"ASN":{`),
resultData: nil,
resultError: errors.New("Couldn't Parse JSON"),
},
}
for _, test := range tests {
res, err := annotation.ParseJSONGeoDataResponse(test.testBuffer)
// This big mishmash of if statements is simply
// checking that if one err is nil, that the other is
// too. Because error messages can vary, this is less
// brittle than doing just err == test.resultError. If
// that is okay, then we just use DeepEqual to compare
// the structs.
if err == nil && test.resultError != nil ||
err != nil && test.resultError == nil {
t.Errorf("Expected %s, got %s for data: %s\n", test.resultError, err, string(test.testBuffer))
} else if !reflect.DeepEqual(res, test.resultData) {
t.Errorf("Expected %+v, got %+v, for data %s\n", test.resultData, res, string(test.testBuffer))
}
}
}
func TestGetBatchGeoData(t *testing.T) {
tests := []struct {
url string
res map[string]annotation.GeoData
}{
{
url: "portGarbage",
res: nil,
},
{
url: "/badJson",
res: nil,
},
{
url: "/goodJson",
res: map[string]annotation.GeoData{"127.0.0.1xyz": {Geo: nil, ASN: nil}},
},
}
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
path := r.URL.Path
if strings.HasSuffix(path, "goodJson") {
fmt.Fprint(w, `{"127.0.0.1xyz": {"Geo":null,"ASN":null}}`)
return
}
fmt.Fprint(w, "{jngngfsljngsljngfsljngsljn")
}))
for _, test := range tests {
res := annotation.GetBatchGeoData(ts.URL+test.url, nil)
if !reflect.DeepEqual(res, test.res) {
t.Errorf("Expected %+v, got %+v for data: %s\n", test.res, res, test.url)
}
}
}
func TestBatchQueryAnnotationService(t *testing.T) {
tests := []struct {
url string
res []byte
err error
}{
{
url: "portGarbage",
res: nil,
err: errors.New("HTTP Protocol Error"),
},
{
url: "/error",
res: nil,
err: errors.New("HTTP 404 Error"),
},
{
url: "/Echo",
res: []byte("Echo"),
err: nil,
},
}
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
path := r.URL.Path
if strings.HasSuffix(path, "error") {
http.Error(w, "Test Error", 404)
return
}
fmt.Fprint(w, "Echo")
}))
for _, test := range tests {
json, err := annotation.BatchQueryAnnotationService(ts.URL+test.url, nil)
if err != nil && test.err == nil || err == nil && test.err != nil {
t.Errorf("Expected %s, got %s, for %s", test.err, err, test.url)
}
if !bytes.Equal(json, test.res) {
t.Errorf("Expected %s, got %s, for %s", string(test.res), string(json), test.url)
}
}
}
func TestBatchParseJSONGeoDataResponse(t *testing.T) {
tests := []struct {
testBuffer []byte
resultData map[string]annotation.GeoData
resultError error
}{
{
// Note: This is not testing for corruptedIP
// addresses. The xyz could be a base36
// encoded timestamp.
testBuffer: []byte(`{"127.0.0.1xyz": {"Geo":null,"ASN":null}}`),
resultData: map[string]annotation.GeoData{"127.0.0.1xyz": {Geo: nil, ASN: nil}},
resultError: nil,
},
{
testBuffer: []byte(`"Geo":{},"ASN":{`),
resultData: nil,
resultError: errors.New("Couldn't Parse JSON"),
},
}
for _, test := range tests {
res, err := annotation.BatchParseJSONGeoDataResponse(test.testBuffer)
// This big mishmash of if statements is simply
// checking that if one err is nil, that the other is
// too. Because error messages can vary, this is less
// brittle than doing just err == test.resultError. If
// that is okay, then we just use DeepEqual to compare
// the structs.
if err == nil && test.resultError != nil ||
err != nil && test.resultError == nil {
t.Errorf("Expected %s, got %s for data: %s\n", test.resultError, err, string(test.testBuffer))
} else if !reflect.DeepEqual(res, test.resultData) {
t.Errorf("Expected %+v, got %+v, for data %s\n", test.resultData, res, string(test.testBuffer))
}
}
}
|
/*
* nighthawk.config.env
*
*/
package config
import (
"database/sql"
"fmt"
"os"
"path/filepath"
"runtime"
)
// Global Environmental Variables
// Directory Setup
var (
BASEDIR = "/opt/nighthawk"
CONFDIR = ""
STATEDIR = ""
DBDIR = ""
MEDIA = ""
TMP = ""
RUNDIR = ""
WORKSPACE = ""
CONFIG_FILE = ""
)
// STANALONE: Run binary without MessageQueue and database
// nighthawk binary can be run in standalone mode
// i.e. Binary directly interacting with Elasticsearch
// and not using RabbitMQ for notification
//var STANDALONE bool = true
var nhrconfig NHRConfig
var hsconfig HashSetConfig
var sdconfig StackDbConfig
var nhdb *sql.DB = nil // nighthawk stack database
const (
CONFIG_FILE_NAME = "nighthawk.json"
LOGGER_DB_NAME = "logger.sqlite3"
)
// Controlling output
const (
OP_CONSOLE_ONLY = 1
OP_DATASTORE_ONLY = 2
OP_CONSOLE_DATASTORE = 3
OP_SPLUNK_FILE = 4
OP_SPLUNK = 5
)
// Initialze all global configuration
func init() {
if runtime.GOOS == "windows" {
BASEDIR = "C:\\ProgramData\\nighthawk"
}
CONFDIR = filepath.Join(BASEDIR, "etc")
STATEDIR = filepath.Join(BASEDIR, "var")
DBDIR = filepath.Join(STATEDIR, "db")
MEDIA = filepath.Join(STATEDIR, "media")
TMP = filepath.Join(STATEDIR, "tmp")
RUNDIR = filepath.Join(STATEDIR, "run")
WORKSPACE = filepath.Join(STATEDIR, "workspace")
CONFIG_FILE = filepath.Join(CONFDIR, CONFIG_FILE_NAME)
// Currently Only supported for Windows
SetNighthawkDirectory()
// Load default configuration at startup
// configuration options will be updated once
// appropriate configuration file is used
nhrconfig.LoadDefaultConfig()
// Setting default Index names for HashSet and StackDb
//hsconfig.Index = "hashset"
hsconfig.LoadDefaultConfig()
//sdconfig.Index = "nighthawk.db"
sdconfig.LoadDefaultConfig()
//fmt.Println("Initializing nighthawk configuration")
}
// Create supporting directory structure
// for Windows and Linux to run in standalone mode
func SetNighthawkDirectory() {
if !fileExists(BASEDIR) {
os.MkdirAll(BASEDIR, 0755)
}
if !fileExists(CONFDIR) {
os.MkdirAll(CONFDIR, 0755)
}
if !fileExists(STATEDIR) {
os.MkdirAll(STATEDIR, 0755)
}
if !fileExists(WORKSPACE) {
os.MkdirAll(WORKSPACE, 0755)
}
if !fileExists(TMP) {
os.MkdirAll(TMP, 0755)
}
if !fileExists(DBDIR) {
os.MkdirAll(DBDIR, 0755)
}
if !fileExists(RUNDIR) {
os.MkdirAll(RUNDIR, 0755)
}
if !fileExists(CONFIG_FILE) {
var nhr NHRConfig
nhr.LoadDefaultConfig()
nhr.SaveConfigFile(CONFIG_FILE)
}
}
// Local fileExists copy to avoid import cycle
func fileExists(path string) bool {
_, err := os.Stat(path)
if err == nil {
return true
}
if os.IsNotExist(err) {
return false
}
panic(err)
}
// Statically defined rabbitmq filename and configuration directory
func isRabbitMQConfigured() bool {
fh, err := os.Open(filepath.Join(CONFDIR, "rabbitmq.json"))
if err != nil {
return true
}
defer fh.Close()
return false
}
/******************************************************
*** External API
******************************************************/
func SetConfigFile(configfile string) {
CONFIG_FILE = configfile
}
func LoadNighthawkConfig() error {
tnhrconfig, err := LoadConfigFile(CONFIG_FILE)
if err != nil {
return err
}
// Setting global NHRconfig
nhrconfig = tnhrconfig
//hsconfig.LookupEnabled = CheckHashSet()
//sdconfig.LookupEnabled = CheckStack()
if CheckHashSet() {
fmt.Println("LoadNighthawkConfig - Initializing HastSet")
hsconfig.Initialize()
}
if CheckStack() {
fmt.Println("LoadNighthawkConfig - Initialzing StackDb")
sdconfig.Initialize()
}
// default return
return nil
}
|
// ticker project doc.go
/*
ticker document
*/
package main
|
package main
import (
"fmt"
"os"
"github.com/jinzhu/gorm"
_ "github.com/jinzhu/gorm/dialects/postgres"
)
var db *gorm.DB
func DB_Init() {
var err error
dbHost := os.Getenv("DB_HOST")
dbPort := os.Getenv("DB_PORT")
dbName := os.Getenv("DB_NAME")
dbUser := os.Getenv("DB_USER")
dbPass := os.Getenv("DB_PASS")
query := fmt.Sprintf("host=%s port=%s user=%s dbname=%s password=%s sslmode=disable", dbHost, dbPort, dbUser, dbName, dbPass)
fmt.Println(query)
db, err = gorm.Open("postgres", query)
if err != nil {
panic(fmt.Sprintf("failed to connect database: %s", err.Error()))
}
}
func GetDB() *gorm.DB {
return db
}
|
package lintcode
/**
* @param a: A 32bit integer
* @param b: A 32bit integer
* @param n: A 32bit integer
* @return: An integer
*/
func fastPower(a int, b int, n int) int {
// (a*b)%n=((a%n)*(b%n))%n
// a^n=(a^(n/2))*(a^(n/2))=...
if n == 0 {
return 1 % b
}
if n == 1 {
return a % b
}
halfPower := fastPower(a, b, n/2)
if n%2 == 0 {
return (halfPower * halfPower) % b
}
return (((halfPower * halfPower) % b) * (a % b)) % b
}
|
package main
func foo() {
bar()
}
func bar() {
}
func main() {
foo()
}
|
package binary_search
import (
"fmt"
"testing"
)
var arr = []int{1, 3, 3, 5, 7, 8, 12, 13}
var arr2 = []int{1, 2, 2, 2, 3}
func TestFindIndex(t *testing.T) {
// 返回5
fmt.Println(FindIndex(arr, 8))
// 返回2，实际上返回1、2、3都对应target=2
// 无法处理边界问题
fmt.Println(FindIndex(arr2, 2))
}
func TestFindLeftBoundIndexFirst(t *testing.T) {
// 返回左边界第一个
fmt.Println(FindLeftBoundIndexFirst(arr2, 2))
}
func TestFindRightBoundIndexFirst(t *testing.T) {
fmt.Println(FindRightBoundIndexFirst(arr2, 2))
} |
package controllers
import (
"encoding/json"
"net/http"
"github.com/adjust/rmq/v3"
"github.com/jinzhu/gorm"
"github.com/kazetora/evermos-assignment/problem_1_ecommerce/helpers"
"github.com/kazetora/evermos-assignment/problem_1_ecommerce/models"
"github.com/kazetora/evermos-assignment/problem_1_ecommerce/requests"
"github.com/kazetora/evermos-assignment/problem_1_ecommerce/storage"
"github.com/kazetora/evermos-assignment/problem_1_ecommerce/taskqueue"
)
// OrderController controller class for Order management
type OrderController struct {
Db *gorm.DB
RmqConn rmq.Connection
}
// NewOrderController OderController class constructor
// params:
// - db: gorm db object
func NewOrderController(db *gorm.DB) *OrderController {
return &OrderController{
Db: db,
}
}
// AddToCart add item to current order
func (c *OrderController) AddToCart(w http.ResponseWriter, r *http.Request) {
decoder := json.NewDecoder(r.Body)
req := requests.AddToCartRequest{}
if err := decoder.Decode(&req); err != nil {
helpers.RespondError(w, http.StatusBadRequest, err.Error())
return
}
defer r.Body.Close()
// create a transaction
transactionKey, err := storage.RegisterTransaction(models.TransactionCache{
UserID: req.UserID,
Status: models.TransactionStatusUnprocessed,
ProductID: req.ProductID,
Quantity: req.Quantity,
})
if err != nil {
helpers.RespondError(w, http.StatusBadRequest, err.Error())
return
}
err = taskqueue.PublshToOrderTaskQueue(transactionKey)
if err != nil {
helpers.RespondError(w, http.StatusInternalServerError, err.Error())
return
}
helpers.RespondJSON(w, http.StatusCreated, map[string]string{"transaction_key": transactionKey})
}
func createDBTransaction(db *gorm.DB, req requests.AddToCartRequest) (models.Transactions, error) {
transaction := models.Transactions{
UserID: req.UserID,
Status: models.TransactionStatusUnprocessed,
}
if err := db.Create(&transaction).Error; err != nil {
// helpers.RespondError(w, http.StatusInternalServerError, err.Error())
return transaction, err
}
return transaction, nil
}
|
package main
import (
"codewizards/runner"
)
func main() {
runner.Start(New)
}
|
//
// Copyright 2019 Chef Software, Inc.
// Author: Salim Afiune <afiune@chef.io>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
package cmd
import (
"fmt"
"os"
"github.com/chef/go-libs/credentials"
"github.com/spf13/cobra"
"github.com/spf13/viper"
"github.com/chef/chef-analyze/pkg/dist"
)
var (
rootCmd = &cobra.Command{
Use: dist.Exec,
Short: fmt.Sprintf("A CLI to analyze artifacts from a %s", dist.ServerProduct),
Long: fmt.Sprintf(`Analyze your %s artifacts to understand the effort to upgrade
your infrastructure by generating reports, automatically fixing violations
and/or deprecations, and generating Effortless packages.
`, dist.ServerProduct),
}
)
// Execute runs the root command
func Execute() error {
return rootCmd.Execute()
}
func init() {
cobra.OnInitialize(initConfig)
// @afiune we can't use viper to bind the flags since our config doesn't really match
// any valid toml structure. (that is, the .chef/credentials toml file)
//
// TODO: revisit
//viper.BindPFlag("client_name", rootCmd.PersistentFlags().Lookup("client_name"))
//viper.BindPFlag("client_key", rootCmd.PersistentFlags().Lookup("client_key"))
//viper.BindPFlag("chef_server_url", rootCmd.PersistentFlags().Lookup("chef_server_url"))
//viper.BindPFlag("profile", rootCmd.PersistentFlags().Lookup("profile"))
// adds the report command from 'cmd/report.go'
rootCmd.AddCommand(reportCmd)
// adds the config command from 'cmd/config.go'
rootCmd.AddCommand(configCmd)
// adds the upload command from 'cmd/upload.go'
rootCmd.AddCommand(uploadCmd)
// adds the session command from 'cmd/session.go'
rootCmd.AddCommand(sessionCmd)
// adds the capture command from 'cmd/capture.go'
rootCmd.AddCommand(captureCmd)
}
func initConfig() {
if reportsFlags.credsFile != "" {
// Use credentials file from the flag
viper.SetConfigFile(reportsFlags.credsFile)
} else {
// Find the credentials and pass it to viper
credsFile, err := credentials.FindCredentialsFile()
// @afiune we don't exit with and error code here because if we do
// the user will never be able to fix the config with the commands:
// $ chef-analyze config init
//
// This verification has been moved to config.FromViper()
if err == nil {
viper.SetConfigFile(credsFile)
} else {
if !hasMinimumParams() && isReportCommand() {
fmt.Printf("Error: %s\n", MissingMinimumParametersErr)
rootCmd.Usage()
os.Exit(-1)
}
//debug("Unable to file credentials: %s", err.Error())
}
}
viper.SetConfigType("toml")
viper.AutomaticEnv()
}
// tells you if the command was run with the minimum parameters for
// this tool to work, with or without credentials config
// TODO @afiune revisit
func hasMinimumParams() bool {
if reportsFlags.chefServerURL != "" &&
reportsFlags.clientName != "" &&
reportsFlags.clientKey != "" {
return true
}
return false
}
func isReportCommand() bool {
if len(os.Args) <= 1 {
return false
}
if os.Args[1] == "report" {
return true
}
return false
}
func isHelpCommand() bool {
if len(os.Args) <= 1 {
return false
}
if os.Args[1] == "help" {
return true
}
return false
}
// overrides the credentials from the viper bound flags
func overrideCredentials() credentials.OverrideFunc {
return func(c *credentials.Credentials) {
if reportsFlags.clientName != "" {
c.ClientName = reportsFlags.clientName
}
if reportsFlags.clientKey != "" {
c.ClientKey = reportsFlags.clientKey
}
if reportsFlags.chefServerURL != "" {
c.ChefServerUrl = reportsFlags.chefServerURL
}
}
}
|
package parsing
import (
"github.com/spf13/cobra"
"github.com/spf13/viper"
"github.com/wish/ctl/pkg/client"
"github.com/wish/ctl/pkg/client/filter"
v1 "k8s.io/api/core/v1"
"regexp"
"strings"
)
// LabelMatchFromCmd automatically parses the "label" flag from a command
// and returns the filtering.LabelMatch specified.
func LabelMatchFromCmd(cmd *cobra.Command) (filter.LabelMatch, error) {
s, _ := cmd.Flags().GetStringArray("label")
for _, label := range viper.GetStringSlice("label_flags") {
if v, err := cmd.Flags().GetString(label); err == nil && len(v) > 0 {
s = append(s, label+"="+v)
}
}
return LabelMatchSlice(s)
}
//StatusFromCmd automatically parses the status flag from a command
//and returns the filtering.StatusMatch specified.
func StatusFromCmd(cmd *cobra.Command) (filter.StatusMatch, error) {
s , err := cmd.Flags().GetString("status")
status := filter.StatusMatch{State: v1.PodPhase(s)}
return status, err
}
// ListOptions parses a client.ListOptions from a command
func ListOptions(cmd *cobra.Command, searches []string) (client.ListOptions, error) {
l, err := LabelMatchFromCmd(cmd)
s := filter.StatusMatch{}
if cmd.Flags().Lookup("status") != nil {
s, err = StatusFromCmd(cmd)
}
if err != nil {
return client.ListOptions{}, err
}
var re *regexp.Regexp
if len(searches) > 0 {
// Check that each individual search is a valid regex
for _, s := range searches {
if _, err := regexp.Compile(s); err != nil {
return client.ListOptions{}, err
}
}
re, err = regexp.Compile("^(" + strings.Join(searches, ")|^(") + ")")
}
if err != nil {
return client.ListOptions{}, err
}
return client.ListOptions{LabelMatch: l, StatusMatch: s, Search: re}, nil
}
// GetOptions parses a client.GetOptions from a command
func GetOptions(cmd *cobra.Command) (client.GetOptions, error) {
l, err := LabelMatchFromCmd(cmd)
return client.GetOptions{LabelMatch: l}, err
}
// LogOptions parses a client.LogOptions from a command
func LogOptions(cmd *cobra.Command, searches []string) (client.LogOptions, error) {
l, err := LabelMatchFromCmd(cmd)
var re *regexp.Regexp
if len(searches) > 0 {
// Check that each individual search is a valid regex
for _, s := range searches {
if _, err := regexp.Compile(s); err != nil {
return client.LogOptions{}, err
}
}
re, err = regexp.Compile("^(" + strings.Join(searches, ")|^(") + ")")
}
if err != nil {
return client.LogOptions{}, err
}
return client.LogOptions{LabelMatch: l, Follow: false, Search: re}, nil
}
|
package writer_test
import (
"bytes"
"github.com/saschagrunert/go-docgen/internal/writer"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/urfave/cli"
)
// The actual test suite
var _ = t.Describe("Writer", func() {
t.Describe("New", func() {
It("should succeed", func() {
// Given
app := cli.NewApp()
// When
res := writer.New(app)
// Then
Expect(res).NotTo(BeNil())
})
})
t.Describe("Write", func() {
It("should succeed", func() {
// Given
w := writer.New(t.Sut)
var b bytes.Buffer
// When
err := w.Write(&b)
// Then
Expect(err).To(BeNil())
Expect(b.String()).To(ContainSubstring("# DESCRIPTION"))
Expect(b.String()).To(ContainSubstring("# NAME"))
Expect(b.String()).To(ContainSubstring("# SYNOPSIS"))
})
})
})
|
package main
import (
"context"
"fmt"
"github.com/yxxyun/ripple/crypto"
"github.com/yxxyun/ripple/data"
rpc "github.com/yxxyun/ripple/rpc/v1"
"google.golang.org/grpc"
)
func main() {
seed, _ := crypto.NewRippleHashCheck("sapqGRrejEA8Z3mbAGqiuBNak4HHs", crypto.RIPPLE_FAMILY_SEED)
key, _ := crypto.NewECDSAKey(seed.Payload())
zero := uint32(0)
src, _ := data.NewAccountFromAddress("rpvsmj5w2iuFv78SyN44NcJt9nrskfRYCA")
dest, _ := data.NewAccountFromAddress("r3mQPV1CKHo67VdpUmu4iWVfyTxNTiDujn")
amount, _ := data.NewAmount("1/XRP")
fee, _ := data.NewNativeValue(int64(12))
txflag := new(data.TransactionFlag)
*txflag = *txflag | data.TxCanonicalSignature
conn, err := grpc.Dial("test.xrp.xpring.io:50051", grpc.WithInsecure())
if err != nil {
fmt.Println(err.Error())
}
defer conn.Close()
client := rpc.NewXRPLedgerAPIServiceClient(conn)
addr := rpc.AccountAddress{
Address: "rpvsmj5w2iuFv78SyN44NcJt9nrskfRYCA",
}
acctinforeq := rpc.GetAccountInfoRequest{
Account: &addr,
}
acctinforesp, _ := client.GetAccountInfo(context.Background(), &acctinforeq)
fmt.Println(acctinforesp)
ledgerSequence := acctinforesp.GetLedgerIndex() + 3
accountSequence := acctinforesp.GetAccountData().GetSequence().GetValue()
tx := &data.Payment{
Destination: *dest,
Amount: *amount,
}
tx.TxBase = data.TxBase{
Account: *src,
Fee: *fee,
TransactionType: data.PAYMENT,
Flags: txflag,
LastLedgerSequence: &ledgerSequence,
Sequence: accountSequence,
}
data.Sign(tx, key, &zero)
_, raw, _ := data.Raw(tx)
submittx := rpc.SubmitTransactionRequest{
SignedTransaction: raw,
}
resp, _ := client.SubmitTransaction(context.Background(), &submittx)
fmt.Println(resp)
fmt.Println(fmt.Sprintf("%X", resp.GetHash()))
}
|
package nimbus
import (
"sort"
"strings"
)
// a singular portion of the entire word cloud
type nimbus struct {
Word string
Count int
}
type ByCount []nimbus
// sorting functions
func (a ByCount) Len() int { return len(a) }
func (a ByCount) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByCount) Less(i, j int) bool { return a[i].Count < a[j].Count }
// golang tutorial #45
func WordCount(s string) map[string]int {
wordMap := make(map[string]int)
for _, word := range strings.Fields(s) {
wordMap[word] += 1
}
return wordMap
}
// check if a string is within a slice
func stringInSlice(a string, list []string) bool {
for _, b := range list {
if b == a {
return true
}
}
return false
}
// trim a map that is a representation of a word cloud
func TrimWordCountMap(untrimmedWordCloud map[string]int, n int, filterStopWords bool) map[string]int {
// create a slice of nimbus
var nimbusSlice = []nimbus{}
// add each nimbus to the slice, if it isn't part of stopwords
for k, v := range untrimmedWordCloud {
if filterStopWords == true {
if stringInSlice(k, StopWords) == true {
continue
}
}
nimbusSlice = append(nimbusSlice, nimbus{Word: k, Count: v})
}
// do some length calculations
nsLength := len(nimbusSlice)
newLength := nsLength - n
// ensure no out-of-bounds error
if newLength <= 0 {
return untrimmedWordCloud
}
// sort by count
sort.Sort(ByCount(nimbusSlice))
// cut off everything after the first n elements of the slice
nimbusSlice = nimbusSlice[newLength:]
// make a new map that contains the slice data, return it
m := make(map[string]int)
for _, nim := range nimbusSlice {
m[nim.Word] += nim.Count
}
return m
}
|
package el
// Handle ElPacket's fragmentation
import (
"sync"
"time"
)
const (
// Fragment Threshold
FRG_THRES = 32
// Max Fragments
MAX_FRAGS = 8
)
// var elFrager *ElFragmenter
type elSequencer interface {
Seq() uint32
}
type elFragCacheRecord struct {
ts int64
p *ElPacket
}
type elFragCache struct {
cache map[uint32]*elFragCacheRecord
flushPeriod time.Time
lock sync.RWMutex
}
func newElFragCache(fp time.Duration) *elFragCache {
c := new(elFragCache)
c.cache = make(map[uint32]*elFragCacheRecord)
go func() {
ticker := time.NewTicker(fp)
for {
<-ticker.C
c.checkExpired()
}
}()
return c
}
func (c *elFragCache) checkExpired() {
removeKey := func(k uint32) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.cache, k)
}
nowts := time.Now().Unix()
for k, v := range c.cache {
if nowts-v.ts > 60 {
removeKey(k)
}
}
}
func (c *elFragCache) insert(k uint32, p *elFragCacheRecord) {
c.lock.Lock()
c.cache[k] = p
c.lock.Unlock()
}
func (c *elFragCache) get(k uint32) (*elFragCacheRecord, bool) {
c.lock.RLock()
v, found := c.cache[k]
c.lock.RUnlock()
return v, found
}
type ElFragmenter struct {
morpher ElMorpher
cache *elFragCache
}
func newElFragmenter(m ElMorpher) *ElFragmenter {
hf := new(ElFragmenter)
hf.morpher = m
hf.cache = newElFragCache(30 * time.Second)
return hf
}
func (hf *ElFragmenter) Fragmentate(c elSequencer, frame []byte) []*ElPacket {
seq := c.Seq()
frameSize := len(frame)
packets := make([]*ElPacket, 0, MAX_FRAGS)
// Debug start
/*
hp := new(ElPacket)
hp.Seq = seq
hp.Flag = HOP_FLG_DAT
hp.Frag = uint8(0)
hp.Plen = uint16(frameSize)
hp.FragPrefix = uint16(0)
hp.setPayload(frame)
logger.Debug("seq: %d, plen: %d, dlen: %d", seq, hp.Plen, hp.Dlen)
packets = append(packets, hp)
return packets
*/
// Debug end
prefixes := make([]int, 0, MAX_FRAGS)
prefix := 0
padding := 0
for i, restSize := 0, frameSize; i < MAX_FRAGS; i++ {
fragSize := hf.morpher.NextPackSize()
//logger.Debug("restSize: %d, fragSize: %d", restSize, fragSize)
delta := restSize - fragSize
if delta < FRG_THRES {
if delta < -FRG_THRES {
padding = -delta
}
prefix += restSize
prefixes = append(prefixes, prefix)
break
} else {
if i == MAX_FRAGS-1 {
prefix += restSize
} else {
prefix += fragSize
restSize -= fragSize
}
}
prefixes = append(prefixes, prefix)
}
start := 0
for i, q := range prefixes {
hp := new(ElPacket)
hp.Seq = seq
hp.Flag = HOP_FLG_DAT | HOP_FLG_MFR
hp.Frag = uint8(i)
hp.Plen = uint16(frameSize)
hp.FragPrefix = uint16(start)
hp.setPayload(frame[start:q])
packets = append(packets, hp)
start = q
}
//logger.Debug("packSize: %d, fragSize: %v", frameSize, prefixes)
last := len(packets) - 1
packets[last].Flag ^= HOP_FLG_MFR
if padding > 0 {
packets[last].addNoise(padding)
}
return packets
}
func (hf *ElFragmenter) reAssemble(packets []*ElPacket) []*ElPacket {
rpacks := make([]*ElPacket, 0, len(packets))
now := time.Now().Unix()
hf.cache.lock.Lock()
defer func() {
hf.cache.lock.Unlock()
if err := recover(); err != nil {
logger.Error("Error reassemble packet fragments: %s", err)
}
}()
for _, p := range packets {
// logger.Debug("frag: %v", p.elPacketHeader)
if p.Dlen == p.Plen {
// logger.Debug("rpacket: %v", p.elPacketHeader)
rpacks = append(rpacks, p)
continue
}
if r, found := hf.cache.cache[p.Seq]; found {
rp := r.p
// logger.Debug("plen: %d, recved: %d", rp.Plen, rp.Dlen)
rp.Dlen += p.Dlen
s := p.FragPrefix
e := s + p.Dlen
rp.Flag ^= ((p.Flag & HOP_FLG_MFR) ^ HOP_FLG_MFR)
copy(rp.payload[s:e], p.payload)
if rp.Dlen == rp.Plen {
rp.Flag ^= HOP_FLG_MFR
// logger.Debug("rpacket: %v", rp.elPacketHeader)
rpacks = append(rpacks, rp)
delete(hf.cache.cache, p.Seq)
}
} else {
payload := make([]byte, p.Plen)
s := p.FragPrefix
e := s + p.Dlen
p.Flag = HOP_FLG_DAT ^ ((p.Flag & HOP_FLG_MFR) ^ HOP_FLG_MFR)
p.Frag = uint8(0xFF)
copy(payload[s:e], p.payload)
p.payload = payload
record := &elFragCacheRecord{ts: now, p: p}
hf.cache.cache[p.Seq] = record
}
}
return rpacks
}
|
/*
Copyright 2021 The KubeVela Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package usecase
import (
"context"
"errors"
"fmt"
"strconv"
"helm.sh/helm/v3/pkg/time"
appsv1 "k8s.io/api/apps/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/klog/v2"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/yaml"
"github.com/oam-dev/kubevela/apis/core.oam.dev/v1beta1"
"github.com/oam-dev/kubevela/pkg/apiserver/clients"
"github.com/oam-dev/kubevela/pkg/apiserver/datastore"
"github.com/oam-dev/kubevela/pkg/apiserver/log"
"github.com/oam-dev/kubevela/pkg/apiserver/model"
apisv1 "github.com/oam-dev/kubevela/pkg/apiserver/rest/apis/v1"
"github.com/oam-dev/kubevela/pkg/apiserver/rest/utils"
"github.com/oam-dev/kubevela/pkg/apiserver/rest/utils/bcode"
"github.com/oam-dev/kubevela/pkg/oam"
"github.com/oam-dev/kubevela/pkg/oam/util"
"github.com/oam-dev/kubevela/pkg/utils/apply"
)
// WorkflowUsecase workflow manage api
type WorkflowUsecase interface {
ListApplicationWorkflow(ctx context.Context, app *model.Application) ([]*apisv1.WorkflowBase, error)
GetWorkflow(ctx context.Context, app *model.Application, workflowName string) (*model.Workflow, error)
DetailWorkflow(ctx context.Context, workflow *model.Workflow) (*apisv1.DetailWorkflowResponse, error)
GetApplicationDefaultWorkflow(ctx context.Context, app *model.Application) (*model.Workflow, error)
DeleteWorkflow(ctx context.Context, app *model.Application, workflowName string) error
DeleteWorkflowByApp(ctx context.Context, app *model.Application) error
CreateOrUpdateWorkflow(ctx context.Context, app *model.Application, req apisv1.CreateWorkflowRequest) (*apisv1.DetailWorkflowResponse, error)
UpdateWorkflow(ctx context.Context, workflow *model.Workflow, req apisv1.UpdateWorkflowRequest) (*apisv1.DetailWorkflowResponse, error)
CreateWorkflowRecord(ctx context.Context, appModel *model.Application, app *v1beta1.Application, workflow *model.Workflow) error
ListWorkflowRecords(ctx context.Context, workflow *model.Workflow, page, pageSize int) (*apisv1.ListWorkflowRecordsResponse, error)
DetailWorkflowRecord(ctx context.Context, workflow *model.Workflow, recordName string) (*apisv1.DetailWorkflowRecordResponse, error)
SyncWorkflowRecord(ctx context.Context) error
ResumeRecord(ctx context.Context, appModel *model.Application, workflow *model.Workflow, recordName string) error
TerminateRecord(ctx context.Context, appModel *model.Application, workflow *model.Workflow, recordName string) error
RollbackRecord(ctx context.Context, appModel *model.Application, workflow *model.Workflow, recordName, revisionName string) error
CountWorkflow(ctx context.Context, app *model.Application) int64
}
// NewWorkflowUsecase new workflow usecase
func NewWorkflowUsecase(ds datastore.DataStore) WorkflowUsecase {
kubecli, err := clients.GetKubeClient()
if err != nil {
log.Logger.Fatalf("get kubeclient failure %s", err.Error())
}
return &workflowUsecaseImpl{
ds: ds,
kubeClient: kubecli,
apply: apply.NewAPIApplicator(kubecli),
}
}
type workflowUsecaseImpl struct {
ds datastore.DataStore
kubeClient client.Client
apply apply.Applicator
}
// DeleteWorkflow delete application workflow
func (w *workflowUsecaseImpl) DeleteWorkflow(ctx context.Context, app *model.Application, workflowName string) error {
var workflow = &model.Workflow{
Name: workflowName,
AppPrimaryKey: app.PrimaryKey(),
}
var record = model.WorkflowRecord{
AppPrimaryKey: workflow.AppPrimaryKey,
WorkflowName: workflow.Name,
}
records, err := w.ds.List(ctx, &record, &datastore.ListOptions{})
if err != nil {
log.Logger.Errorf("list workflow %s record failure %s", workflow.PrimaryKey(), err.Error())
}
for _, record := range records {
if err := w.ds.Delete(ctx, record); err != nil {
log.Logger.Errorf("delete workflow record %s failure %s", record.PrimaryKey(), err.Error())
}
}
if err := w.ds.Delete(ctx, workflow); err != nil {
if errors.Is(err, datastore.ErrRecordNotExist) {
return bcode.ErrWorkflowNotExist
}
return err
}
return nil
}
func (w *workflowUsecaseImpl) DeleteWorkflowByApp(ctx context.Context, app *model.Application) error {
var workflow = &model.Workflow{
AppPrimaryKey: app.PrimaryKey(),
}
workflows, err := w.ds.List(ctx, workflow, &datastore.ListOptions{})
if err != nil {
if errors.Is(err, datastore.ErrRecordNotExist) {
return nil
}
return err
}
for i := range workflows {
workflow := workflows[i].(*model.Workflow)
var record = model.WorkflowRecord{
AppPrimaryKey: workflow.AppPrimaryKey,
WorkflowName: workflow.Name,
}
records, err := w.ds.List(ctx, &record, &datastore.ListOptions{})
if err != nil {
log.Logger.Errorf("list workflow %s record failure %s", workflow.PrimaryKey(), err.Error())
}
for _, record := range records {
if err := w.ds.Delete(ctx, record); err != nil {
log.Logger.Errorf("delete workflow record %s failure %s", record.PrimaryKey(), err.Error())
}
}
if err := w.ds.Delete(ctx, workflow); err != nil {
log.Logger.Errorf("delete workflow %s failure %s", workflow.PrimaryKey(), err.Error())
}
}
return nil
}
func (w *workflowUsecaseImpl) CreateOrUpdateWorkflow(ctx context.Context, app *model.Application, req apisv1.CreateWorkflowRequest) (*apisv1.DetailWorkflowResponse, error) {
if req.EnvName == "" {
return nil, bcode.ErrWorkflowNoEnv
}
workflow, err := w.GetWorkflow(ctx, app, req.Name)
if err != nil && errors.Is(err, datastore.ErrRecordNotExist) {
return nil, err
}
var steps []model.WorkflowStep
for _, step := range req.Steps {
properties, err := model.NewJSONStructByString(step.Properties)
if err != nil {
log.Logger.Errorf("parse trait properties failire %w", err)
return nil, bcode.ErrInvalidProperties
}
steps = append(steps, model.WorkflowStep{
Name: step.Name,
Type: step.Type,
Alias: step.Alias,
Inputs: step.Inputs,
Outputs: step.Outputs,
Description: step.Description,
DependsOn: step.DependsOn,
Properties: properties,
})
}
if workflow != nil {
workflow.Steps = steps
workflow.Alias = req.Alias
workflow.Description = req.Description
workflow.Default = &req.Default
if err := w.ds.Put(ctx, workflow); err != nil {
return nil, err
}
} else {
// It is allowed to set multiple workflows as default, and only one takes effect.
workflow = &model.Workflow{
Steps: steps,
Name: req.Name,
Alias: req.Alias,
Description: req.Description,
Default: &req.Default,
EnvName: req.EnvName,
AppPrimaryKey: app.PrimaryKey(),
}
log.Logger.Infof("create workflow %s for app %s", req.Name, app.PrimaryKey())
if err := w.ds.Add(ctx, workflow); err != nil {
return nil, err
}
}
return w.DetailWorkflow(ctx, workflow)
}
func (w *workflowUsecaseImpl) UpdateWorkflow(ctx context.Context, workflow *model.Workflow, req apisv1.UpdateWorkflowRequest) (*apisv1.DetailWorkflowResponse, error) {
var steps []model.WorkflowStep
for _, step := range req.Steps {
properties, err := model.NewJSONStructByString(step.Properties)
if err != nil {
log.Logger.Errorf("parse trait properties failire %w", err)
return nil, bcode.ErrInvalidProperties
}
steps = append(steps, model.WorkflowStep{
Name: step.Name,
Alias: step.Alias,
Description: step.Description,
DependsOn: step.DependsOn,
Type: step.Type,
Inputs: step.Inputs,
Outputs: step.Outputs,
Properties: properties,
})
}
workflow.Steps = steps
workflow.Description = req.Description
// It is allowed to set multiple workflows as default, and only one takes effect.
workflow.Default = &req.Default
if err := w.ds.Put(ctx, workflow); err != nil {
return nil, err
}
return w.DetailWorkflow(ctx, workflow)
}
func converWorkflowBase(workflow *model.Workflow) apisv1.WorkflowBase {
var steps []apisv1.WorkflowStep
for _, step := range workflow.Steps {
apiStep := apisv1.WorkflowStep{
Name: step.Name,
Type: step.Type,
Alias: step.Alias,
Description: step.Description,
Inputs: step.Inputs,
Outputs: step.Outputs,
Properties: step.Properties.JSON(),
DependsOn: step.DependsOn,
}
if step.Properties != nil {
apiStep.Properties = step.Properties.JSON()
}
steps = append(steps, apiStep)
}
return apisv1.WorkflowBase{
Name: workflow.Name,
Alias: workflow.Alias,
Description: workflow.Description,
Default: convertBool(workflow.Default),
EnvName: workflow.EnvName,
CreateTime: workflow.CreateTime,
UpdateTime: workflow.UpdateTime,
Steps: steps,
}
}
// DetailWorkflow detail workflow
func (w *workflowUsecaseImpl) DetailWorkflow(ctx context.Context, workflow *model.Workflow) (*apisv1.DetailWorkflowResponse, error) {
return &apisv1.DetailWorkflowResponse{
WorkflowBase: converWorkflowBase(workflow),
}, nil
}
// GetWorkflow get workflow model
func (w *workflowUsecaseImpl) GetWorkflow(ctx context.Context, app *model.Application, workflowName string) (*model.Workflow, error) {
var workflow = model.Workflow{
Name: workflowName,
AppPrimaryKey: app.PrimaryKey(),
}
if err := w.ds.Get(ctx, &workflow); err != nil {
if errors.Is(err, datastore.ErrRecordNotExist) {
return nil, bcode.ErrWorkflowNotExist
}
return nil, err
}
return &workflow, nil
}
// ListApplicationWorkflow list application workflows
func (w *workflowUsecaseImpl) ListApplicationWorkflow(ctx context.Context, app *model.Application) ([]*apisv1.WorkflowBase, error) {
var workflow = model.Workflow{
AppPrimaryKey: app.PrimaryKey(),
}
workflows, err := w.ds.List(ctx, &workflow, &datastore.ListOptions{})
if err != nil {
return nil, err
}
var list []*apisv1.WorkflowBase
for _, workflow := range workflows {
wm := workflow.(*model.Workflow)
base := converWorkflowBase(wm)
list = append(list, &base)
}
return list, nil
}
// GetApplicationDefaultWorkflow get application default workflow
func (w *workflowUsecaseImpl) GetApplicationDefaultWorkflow(ctx context.Context, app *model.Application) (*model.Workflow, error) {
var defaultEnable = true
var workflow = model.Workflow{
AppPrimaryKey: app.PrimaryKey(),
Default: &defaultEnable,
}
workflows, err := w.ds.List(ctx, &workflow, &datastore.ListOptions{})
if err != nil {
return nil, err
}
if len(workflows) > 0 {
return workflows[0].(*model.Workflow), nil
}
return nil, bcode.ErrWorkflowNoDefault
}
// ListWorkflowRecords list workflow record
func (w *workflowUsecaseImpl) ListWorkflowRecords(ctx context.Context, workflow *model.Workflow, page, pageSize int) (*apisv1.ListWorkflowRecordsResponse, error) {
var record = model.WorkflowRecord{
AppPrimaryKey: workflow.AppPrimaryKey,
WorkflowName: workflow.Name,
}
records, err := w.ds.List(ctx, &record, &datastore.ListOptions{Page: page, PageSize: pageSize})
if err != nil {
return nil, err
}
resp := &apisv1.ListWorkflowRecordsResponse{
Records: []apisv1.WorkflowRecord{},
}
for _, raw := range records {
record, ok := raw.(*model.WorkflowRecord)
if ok {
resp.Records = append(resp.Records, *convertFromRecordModel(record))
}
}
count, err := w.ds.Count(ctx, &record, nil)
if err != nil {
return nil, err
}
resp.Total = count
return resp, nil
}
// DetailWorkflowRecord get workflow record detail with name
func (w *workflowUsecaseImpl) DetailWorkflowRecord(ctx context.Context, workflow *model.Workflow, recordName string) (*apisv1.DetailWorkflowRecordResponse, error) {
var record = model.WorkflowRecord{
AppPrimaryKey: workflow.AppPrimaryKey,
WorkflowName: workflow.Name,
Name: recordName,
}
err := w.ds.Get(ctx, &record)
if err != nil {
if errors.Is(err, datastore.ErrRecordNotExist) {
return nil, bcode.ErrWorkflowRecordNotExist
}
return nil, err
}
var revision = model.ApplicationRevision{
AppPrimaryKey: record.AppPrimaryKey,
Version: record.RevisionPrimaryKey,
}
err = w.ds.Get(ctx, &revision)
if err != nil {
if errors.Is(err, datastore.ErrRecordNotExist) {
return nil, bcode.ErrApplicationRevisionNotExist
}
return nil, err
}
return &apisv1.DetailWorkflowRecordResponse{
WorkflowRecord: *convertFromRecordModel(&record),
DeployTime: revision.CreateTime,
DeployUser: revision.DeployUser,
Note: revision.Note,
TriggerType: revision.TriggerType,
}, nil
}
func (w *workflowUsecaseImpl) SyncWorkflowRecord(ctx context.Context) error {
var record = model.WorkflowRecord{
Finished: "false",
}
// list all unfinished workflow records
records, err := w.ds.List(ctx, &record, &datastore.ListOptions{})
if err != nil {
return err
}
for _, item := range records {
app := &v1beta1.Application{}
record := item.(*model.WorkflowRecord)
workflow := &model.Workflow{
Name: record.WorkflowName,
AppPrimaryKey: record.AppPrimaryKey,
}
if err := w.ds.Get(ctx, workflow); err != nil {
log.Logger.Errorf("get workflow %s/%s failure %s", record.AppPrimaryKey, record.WorkflowName, err.Error())
continue
}
if err := w.kubeClient.Get(ctx, types.NamespacedName{
Name: convertAppName(record.AppPrimaryKey, workflow.EnvName),
Namespace: record.Namespace,
}, app); err != nil {
klog.ErrorS(err, "failed to get app", "app name", record.AppPrimaryKey)
return err
}
// try to sync the status from the running application
if app.Annotations != nil && app.Annotations[oam.AnnotationPublishVersion] == record.Name {
if err := w.syncWorkflowStatus(ctx, app, record.Name); err != nil {
klog.ErrorS(err, "failed to sync workflow status", "app name", record.AppPrimaryKey, "workflow record name", record.Name)
}
continue
}
// try to sync the status from the controller revision
cr := &appsv1.ControllerRevision{}
if err := w.kubeClient.Get(ctx, types.NamespacedName{
Name: fmt.Sprintf("record-%s-%s", convertAppName(record.AppPrimaryKey, workflow.EnvName), record.Name),
Namespace: record.Namespace,
}, cr); err != nil {
klog.ErrorS(err, "failed to get controller revision", "app name", record.AppPrimaryKey, "workflow record name", record.Name)
continue
}
appInRevision, err := util.RawExtension2Application(cr.Data)
if err != nil {
klog.ErrorS(err, "failed to get app data in controller revision", "controller revision name", cr.Name, "app name", record.AppPrimaryKey, "workflow record name", record.Name)
continue
}
if err := w.syncWorkflowStatus(ctx, appInRevision, record.Name); err != nil {
klog.ErrorS(err, "failed to sync workflow status", "app name", record.AppPrimaryKey, "workflow record version", record.Name)
continue
}
}
return nil
}
func (w *workflowUsecaseImpl) syncWorkflowStatus(ctx context.Context, app *v1beta1.Application, recordName string) error {
var record = &model.WorkflowRecord{
AppPrimaryKey: app.Annotations[oam.AnnotationAppName],
Name: recordName,
}
if err := w.ds.Get(ctx, record); err != nil {
if errors.Is(err, datastore.ErrRecordNotExist) {
return bcode.ErrWorkflowRecordNotExist
}
return err
}
var revision = &model.ApplicationRevision{
AppPrimaryKey: app.Annotations[oam.AnnotationAppName],
Version: record.RevisionPrimaryKey,
}
if err := w.ds.Get(ctx, revision); err != nil {
if errors.Is(err, datastore.ErrRecordNotExist) {
return bcode.ErrApplicationRevisionNotExist
}
return err
}
if app.Status.Workflow != nil {
status := app.Status.Workflow
summaryStatus := model.RevisionStatusRunning
if status.Finished {
summaryStatus = model.RevisionStatusComplete
}
if status.Terminated {
summaryStatus = model.RevisionStatusTerminated
}
record.Status = summaryStatus
record.Steps = status.Steps
record.Finished = strconv.FormatBool(status.Finished)
if err := w.ds.Put(ctx, record); err != nil {
return err
}
revision.Status = summaryStatus
if err := w.ds.Put(ctx, revision); err != nil {
return err
}
}
return nil
}
func (w *workflowUsecaseImpl) CreateWorkflowRecord(ctx context.Context, appModel *model.Application, app *v1beta1.Application, workflow *model.Workflow) error {
if app.Annotations == nil {
return fmt.Errorf("empty annotations in application")
}
if app.Annotations[oam.AnnotationPublishVersion] == "" {
return fmt.Errorf("failed to get record version from application")
}
if app.Annotations[oam.AnnotationDeployVersion] == "" {
return fmt.Errorf("failed to get deploy version from application")
}
return w.ds.Add(ctx, &model.WorkflowRecord{
WorkflowName: workflow.Name,
AppPrimaryKey: appModel.PrimaryKey(),
RevisionPrimaryKey: app.Annotations[oam.AnnotationDeployVersion],
Name: app.Annotations[oam.AnnotationPublishVersion],
Namespace: appModel.Namespace,
Finished: "false",
StartTime: time.Now().Time,
Status: model.RevisionStatusInit,
})
}
func (w *workflowUsecaseImpl) CountWorkflow(ctx context.Context, app *model.Application) int64 {
count, err := w.ds.Count(ctx, &model.Workflow{AppPrimaryKey: app.PrimaryKey()}, &datastore.FilterOptions{})
if err != nil {
log.Logger.Errorf("count app %s workflow failure %s", app.PrimaryKey(), err.Error())
}
return count
}
func (w *workflowUsecaseImpl) ResumeRecord(ctx context.Context, appModel *model.Application, workflow *model.Workflow, recordName string) error {
oamApp, err := w.checkRecordRunning(ctx, appModel, workflow.EnvName)
if err != nil {
return err
}
oamApp.Status.Workflow.Suspend = false
if err := w.kubeClient.Status().Patch(ctx, oamApp, client.Merge); err != nil {
return err
}
if err := w.syncWorkflowStatus(ctx, oamApp, recordName); err != nil {
return err
}
return nil
}
func (w *workflowUsecaseImpl) TerminateRecord(ctx context.Context, appModel *model.Application, workflow *model.Workflow, recordName string) error {
oamApp, err := w.checkRecordRunning(ctx, appModel, workflow.EnvName)
if err != nil {
return err
}
oamApp.Status.Workflow.Terminated = true
if err := w.kubeClient.Status().Patch(ctx, oamApp, client.Merge); err != nil {
return err
}
if err := w.syncWorkflowStatus(ctx, oamApp, recordName); err != nil {
return err
}
return nil
}
func (w *workflowUsecaseImpl) RollbackRecord(ctx context.Context, appModel *model.Application, workflow *model.Workflow, recordName, revisionVersion string) error {
if revisionVersion == "" {
// find the latest complete revision version
var revision = model.ApplicationRevision{
AppPrimaryKey: appModel.Name,
Status: model.RevisionStatusComplete,
}
revisions, err := w.ds.List(ctx, &revision, &datastore.ListOptions{
Page: 1,
PageSize: 1,
SortBy: []datastore.SortOption{{Key: "model.createTime", Order: datastore.SortOrderDescending}},
})
if err != nil {
return err
}
if len(revisions) == 0 {
return bcode.ErrApplicationNoReadyRevision
}
revisionVersion = revisions[0].Index()["version"]
}
var record = &model.WorkflowRecord{
AppPrimaryKey: appModel.PrimaryKey(),
Name: recordName,
}
if err := w.ds.Get(ctx, record); err != nil {
return err
}
oamApp, err := w.checkRecordRunning(ctx, appModel, workflow.EnvName)
if err != nil {
return err
}
var rollbackRevision = model.ApplicationRevision{
AppPrimaryKey: appModel.Name,
Version: revisionVersion,
}
if err := w.ds.Get(ctx, &rollbackRevision); err != nil {
return err
}
rollBackApp := &v1beta1.Application{}
if err := yaml.Unmarshal([]byte(rollbackRevision.ApplyAppConfig), rollBackApp); err != nil {
return err
}
// replace the application spec
oamApp.Spec.Components = rollBackApp.Spec.Components
oamApp.Spec.Policies = rollBackApp.Spec.Policies
if oamApp.Annotations == nil {
oamApp.Annotations = make(map[string]string)
}
newRecordName := utils.GenerateVersion(record.WorkflowName)
oamApp.Annotations[oam.AnnotationDeployVersion] = revisionVersion
oamApp.Annotations[oam.AnnotationPublishVersion] = newRecordName
// create a new workflow record
if err := w.CreateWorkflowRecord(ctx, appModel, oamApp, workflow); err != nil {
return err
}
if err := w.apply.Apply(ctx, oamApp); err != nil {
// rollback error case
if err := w.ds.Delete(ctx, &model.WorkflowRecord{Name: newRecordName}); err != nil {
klog.Error(err, "failed to delete record", newRecordName)
}
return err
}
return nil
}
func (w *workflowUsecaseImpl) checkRecordRunning(ctx context.Context, appModel *model.Application, envName string) (*v1beta1.Application, error) {
oamApp := &v1beta1.Application{}
if err := w.kubeClient.Get(ctx, types.NamespacedName{Name: convertAppName(appModel.Name, envName), Namespace: appModel.Namespace}, oamApp); err != nil {
return nil, err
}
if oamApp.Status.Workflow != nil && !oamApp.Status.Workflow.Suspend && !oamApp.Status.Workflow.Terminated && !oamApp.Status.Workflow.Finished {
return nil, fmt.Errorf("workflow is still running, can not operate a running workflow")
}
oamApp.SetGroupVersionKind(v1beta1.ApplicationKindVersionKind)
return oamApp, nil
}
func convertFromRecordModel(record *model.WorkflowRecord) *apisv1.WorkflowRecord {
return &apisv1.WorkflowRecord{
Name: record.Name,
Namespace: record.Namespace,
StartTime: record.StartTime,
Status: record.Status,
Steps: record.Steps,
}
}
func convertBool(b *bool) bool {
if b == nil {
return false
}
return *b
}
|
package nats_streaming
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/batchcorp/plumber-schemas/build/go/protos/args"
"github.com/batchcorp/plumber-schemas/build/go/protos/opts"
"github.com/batchcorp/plumber/backends/nats-streaming/stanfakes"
"github.com/batchcorp/plumber/types"
"github.com/batchcorp/plumber/validate"
)
var _ = Describe("Nats Streaming Backend", func() {
var connOpts *opts.ConnectionOptions
BeforeEach(func() {
connOpts = &opts.ConnectionOptions{
Conn: &opts.ConnectionOptions_NatsStreaming{
NatsStreaming: &args.NatsStreamingConn{
Dsn: "localhost",
UserCredentials: "",
ClusterId: "test",
ClientId: "plumber",
TlsOptions: &args.NatsStreamingTLSOptions{
TlsSkipVerify: false,
TlsCaCert: "../../test-assets/ssl/ca.crt",
TlsClientCert: "../../test-assets/ssl/client.crt",
TlsClientKey: "../../test-assets/ssl/client.key",
},
},
},
}
})
Context("Name", func() {
It("returns name", func() {
Expect((&NatsStreaming{}).Name()).To(Equal(BackendName))
})
})
Context("Close", func() {
It("calls close on client", func() {
fakeStan := &stanfakes.FakeConn{}
fakeStan.CloseStub = func() error {
return nil
}
err := (&NatsStreaming{stanClient: fakeStan}).Close(nil)
Expect(err).ToNot(HaveOccurred())
Expect(fakeStan.CloseCallCount()).To(Equal(1))
})
})
Context("Test", func() {
It("returns not implemented err", func() {
err := (&NatsStreaming{}).Test(nil)
Expect(err).To(HaveOccurred())
Expect(err).To(Equal(types.NotImplementedErr))
})
})
Context("validateBaseConnOpts", func() {
It("validates conn presence", func() {
err := validateBaseConnOpts(nil)
Expect(err).To(HaveOccurred())
Expect(err).To(Equal(validate.ErrMissingConnOpts))
})
It("validates conn config", func() {
connOpts = &opts.ConnectionOptions{}
err := validateBaseConnOpts(connOpts)
Expect(err).To(HaveOccurred())
Expect(err).To(Equal(validate.ErrMissingConnCfg))
})
It("validates MQTT presence", func() {
connOpts = &opts.ConnectionOptions{
Conn: &opts.ConnectionOptions_NatsStreaming{
NatsStreaming: nil,
},
}
err := validateBaseConnOpts(connOpts)
Expect(err).To(HaveOccurred())
Expect(err).To(Equal(validate.ErrMissingConnArgs))
})
It("passes validation", func() {
err := validateBaseConnOpts(connOpts)
Expect(err).ToNot(HaveOccurred())
})
})
})
|
package main
const (
qPrefix = `
select
history_items.id, title, url
from history_items
inner join history_visits on history_visits.history_item = history_items.id
where
`
qPostfix = `
group by url
order by visit_time desc
limit 40
`
dbFilePath = "./History.db"
)
|
package iirepo_contents_test
import (
"github.com/reiver/go-iirepo/contents"
"fmt"
)
func ExamplePath() {
var parent string = "/home/joeblow/workspaces/myproject"
repoContentsPath := iirepo_contents.Path(parent)
fmt.Printf("The repo's contents directory's path is: %s\n", repoContentsPath)
// Output:
// The repo's contents directory's path is: /home/joeblow/workspaces/myproject/.ii/contents
}
|
package main
import (
"fmt"
)
const (
a = iota
b = iota
c = iota
d = iota
e = iota
f = iota
)
// Reset and start new
//const (
// d = iota
// e = iota
// f = iota
//)
func main() {
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(e)
fmt.Println(f)
fmt.Printf("%T %T %T %T %T %T", a, b, c, d, e, f)
}
|
//
// Copyright 2020 The AVFS authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
package test
import (
"os"
"testing"
"github.com/avfs/avfs"
)
// SuiteIdm is a test suite for an identity manager.
type SuiteIdm struct {
idm avfs.IdentityMgr // idm is the identity manager to be tested.
uc avfs.UserConnecter // uc is the implementation of avfs.UserConnecter.
Groups []avfs.GroupReader // Groups contains the test groups created with the identity manager.
Users []avfs.UserReader // Users contains the test users created with the identity manager.
canTest bool // canTest is true when the identity manager can be tested.
}
// NewSuiteIdm returns a new test suite for an identity manager.
func NewSuiteIdm(t *testing.T, idm avfs.IdentityMgr) *SuiteIdm {
sIdm := &SuiteIdm{idm: idm}
defer func() {
t.Logf("Info Idm = %s, Can test = %t", sIdm.Type(), sIdm.canTest)
}()
uc, ok := idm.(avfs.UserConnecter)
if ok {
sIdm.uc = uc
u := uc.CurrentUser()
if u == nil {
return sIdm
}
if !u.IsRoot() {
return sIdm
}
}
if !idm.HasFeature(avfs.FeatIdentityMgr) {
return sIdm
}
sIdm.canTest = true
sIdm.Groups = CreateGroups(t, idm, "")
sIdm.Users = CreateUsers(t, idm, "")
return sIdm
}
// Type returns the type of the identity manager.
func (sIdm *SuiteIdm) Type() string {
return sIdm.idm.Type()
}
// TestAll run all identity manager tests.
func (sIdm *SuiteIdm) TestAll(t *testing.T) {
sIdm.TestCurrentUser(t)
sIdm.TestGroupAddDel(t)
sIdm.TestUserAddDel(t)
sIdm.TestLookup(t)
sIdm.TestUser(t)
sIdm.TestUserDenied(t)
sIdm.TestPermDenied(t)
}
// GroupInfo contains information to create a test group.
type GroupInfo struct {
Name string
}
const (
grpTest = "grpTest" // grpTest is the default group of the default test user UsrTest.
grpOther = "grpOther" // grpOther is the group to test users who are not members of grpTest.
grpEmpty = "grpEmpty" // grpEmpty is a group without users.
)
// GroupInfos returns a GroupInfo slice describing the test groups.
func GroupInfos() []*GroupInfo {
gis := []*GroupInfo{
{Name: grpTest},
{Name: grpOther},
{Name: grpEmpty},
}
return gis
}
// CreateGroups creates and returns test groups with a suffix appended to each group.
// Errors are ignored if the group already exists.
func CreateGroups(tb testing.TB, idm avfs.IdentityMgr, suffix string) (groups []avfs.GroupReader) {
for _, group := range GroupInfos() {
groupName := group.Name + suffix
g, err := idm.GroupAdd(groupName)
if err != nil && err != avfs.AlreadyExistsGroupError(groupName) {
tb.Fatalf("GroupAdd %s : want error to be nil, got %v", groupName, err)
}
groups = append(groups, g)
}
return
}
// UserInfo contains information to create a test user.
type UserInfo struct {
Name string
GroupName string
}
const (
UsrTest = "UsrTest" // UsrTest is used to test user access rights.
UsrGrp = "UsrGrp" // UsrGrp is a member of the group GrpTest used to test default group access rights.
UsrOth = "UsrOth" // UsrOth is a member of the group GrpOth used to test non members access rights.
)
// UserInfos returns a UserInfo slice describing the test users.
func UserInfos() []*UserInfo {
uis := []*UserInfo{
{Name: UsrTest, GroupName: grpTest},
{Name: UsrGrp, GroupName: grpTest},
{Name: UsrOth, GroupName: grpOther},
}
return uis
}
// CreateUsers creates and returns test users with a suffix appended to each user.
// Errors are ignored if the user or his home directory already exists.
func CreateUsers(tb testing.TB, idm avfs.IdentityMgr, suffix string) (users []avfs.UserReader) {
for _, ui := range UserInfos() {
userName := ui.Name + suffix
groupName := ui.GroupName + suffix
u, err := idm.UserAdd(userName, groupName)
if err != nil {
switch e := err.(type) {
case *os.PathError:
if e.Op != "mkdir" || e.Err != avfs.ErrFileExists {
tb.Fatalf("UserAdd %s : want Mkdir error, got %v", userName, err)
}
default:
if err != avfs.AlreadyExistsUserError(userName) {
tb.Fatalf("UserAdd %s : want error to be nil, got %v", userName, err)
}
}
if u == nil {
u, err = idm.LookupUser(userName)
if err != nil {
tb.Fatalf("LookupUser %s : want error to be nil, got %v", userName, err)
}
}
}
users = append(users, u)
}
return
}
|
package main
import (
"context"
"fmt"
"log"
"os"
"strconv"
"strings"
"time"
"gopkg.in/olivere/elastic.v5"
)
type arr [][]int64
var umap = make(map[string]arr)
func getID(l string) string {
i := strings.Index(l, ":")
id := l[i+1:]
return id
}
func getSeq(l string) int64 {
i := strings.Index(l, ":")
s := l[i+1:]
seq, err := strconv.Atoi(s)
checkErr(err, "getSeq")
return int64(seq)
}
func (q queue) structureUserMap() {
var as = make([]int64, 2)
as[0] = q.datetime
as[1] = q.seq
umap[q.uid] = append(umap[q.uid], as)
}
// checkErr check the err
func checkErr(err error, str string) {
if err != nil {
log.Println(err, str)
}
}
func yoolog() *log.Logger {
logFileName, err := os.Create("log/tmp.log")
checkErr(err, "Create the log file error ! ")
logger := log.New(logFileName, "[golog]", log.LstdFlags)
return logger
}
// 时间差计算
func timeCount(thisOne, previous string) int64 {
this := strToMS(thisOne)
pre := strToMS(previous)
period := this - pre
return period
}
func strReplace(str string) string {
a := strings.Replace(str, "-", "/", -1)
b := strings.Replace(a, ",", ".", -1)
return b
}
func strToUnix(str string) int64 {
t, _ := time.Parse("2006/01/02 15:04:05.999", str)
tt := t.UnixNano() / 10e5
return tt
}
func strToMS(str string) int64 {
return strToUnix(strReplace(str))
}
func connetEs() *elastic.BulkService {
fmt.Println(esAddr())
client, err := elastic.NewClient(elastic.SetURL(esAddr()))
if err != nil {
panic(err)
}
ctx := context.Background()
_, err = client.IndexExists(omogIndex).Do(ctx)
if err != nil {
panic(err)
}
bulkRequest := client.Bulk()
return bulkRequest
}
func wrToEs(indexReq *elastic.BulkIndexRequest, bulkRequest *elastic.BulkService) {
ctx := context.Background()
bulkRequest = bulkRequest.Add(indexReq)
if bulkRequest.NumberOfActions() > putToEs {
_, err := bulkRequest.Do(ctx)
golog.Println(err, "write to es")
}
}
func gotNum(n uint32) {
logi = n / 10000
if logi > logj {
logj = logi
golog.Printf(" had receviced %d !\n", logj*10000)
}
}
|
package main
import (
"fmt"
"strconv"
"math/rand"
"time"
)
type card struct {
mark string
num int
}
func NumToCard(num int) string {
switch num {
case 1:
return "A"
case 11:
return "J"
case 12:
return "Q"
case 13:
return "K"
default:
return strconv.Itoa(num)
}
}
func NumToPoint(num int) int {
switch num {
case 11,12,13:
return 10
default:
return num
}
}
func Print_Mark(mark_string string) string {
switch mark_string {
case "ハート":
return "💛"
case "スペード":
return "♠"
case "ダイヤ":
return "♦"
case "クラブ":
return "♣"
}
return "Error"
}
func Initialize_Deck() []card {
marks := []string{"ハート", "スペード", "ダイヤ", "クラブ"}
var deck []card
var count int = 0
deck = make([]card, 52)
for _, mark := range marks {
for i := 1;i <= 13;i++ {
deck[count].mark = mark
deck[count].num = i
count++
}
}
return deck
}
func Print_Deck(deck []card) {
for i := range deck {
fmt.Printf("%vの%v\n",deck[i].mark, deck[i].num)
}
}
func Print_Card(print_card card, secret int) {
if secret == 0 {
fmt.Printf("%v %v\n", Print_Mark(print_card.mark), NumToCard(print_card.num))
}else{
fmt.Printf("****\n")
}
}
func Drow_Card(deck []card) card {
var drow_card card
var drow_num int
rand.Seed(time.Now().UnixNano())
drow_num = rand.Intn(len(deck))
drow_card.mark = deck[drow_num].mark
drow_card.num = deck[drow_num].num
return drow_card
}
func Delete_Card(deck []card, delete_card card) []card {
result_deck := []card{}
for _, cards := range deck {
if cards.mark != delete_card.mark || cards.num != delete_card.num {
result_deck = append(result_deck, cards)
}
}
return result_deck
}
func Drow_Phase(deck []card, cards []card, turn string, secret int) ([]card, []card) {
var drow_card = Drow_Card(deck)
deck = Delete_Card(deck, drow_card)
cards = Add_Have_Card(cards, drow_card)
if turn == "player" {
fmt.Print("あなた: ")
}else if turn == "croupier" {
fmt.Print("ディーラー: ")
}
Print_Card(drow_card, secret)
return deck, cards
}
func Initialize_game(deck []card, user_cards []card, cpu_cards []card) ([]card, []card, []card) {
var turn string = "player"
fmt.Println("---ブラックジャック---")
fmt.Println("ゲーム開始")
deck, user_cards = Drow_Phase(deck, user_cards, turn, 0)
deck, user_cards = Drow_Phase(deck, user_cards, turn, 0)
turn = "croupier"
deck, cpu_cards = Drow_Phase(deck, cpu_cards, turn, 0)
deck, cpu_cards = Drow_Phase(deck, cpu_cards, turn, 1)
return deck, user_cards, cpu_cards
}
func Player_Turn(deck []card, user_cards []card) ([]card, []card, bool) {
var cont string
var turn string = "player"
var burst_flag bool
for {
fmt.Printf("あなたの現在の得点は%v\n", Print_Point(user_cards))
fmt.Println("カードを引きますか? Y/N")
fmt.Scan(&cont)
if cont == "Y" || cont == "y"{
deck, user_cards = Drow_Phase(deck, user_cards, turn, 0)
if Print_Point(user_cards) > 21 {
fmt.Println("バーストしました")
burst_flag = true
return deck, user_cards, burst_flag
}
} else if cont == "N" || cont == "n" {
return deck, user_cards, burst_flag
} else {
fmt.Println("YかNを入力")
}
}
}
func Croupier_Turn(deck []card, cpu_cards []card) ([]card, []card) {
var turn string = "croupier"
for {
fmt.Printf("ディーラーの現在の得点は%v\n", Print_Point(cpu_cards))
if Print_Point(cpu_cards) < 17 {
deck, cpu_cards = Drow_Phase(deck, cpu_cards, turn, 0)
} else {
return deck, cpu_cards
}
}
}
func Print_Result(user_cards, cpu_cards []card) {
user_point := Print_Point(user_cards)
cpu_point := Print_Point(cpu_cards)
if user_point > cpu_point || cpu_point > 21 {
fmt.Println("あなたの勝ち")
} else if user_point == cpu_point {
fmt.Println("引き分け")
} else {
fmt.Println("あなたの負け")
}
}
func Add_Have_Card(cards []card, add_card card) []card {
cards = append(cards, add_card)
return cards
}
func Print_Point(cards []card) int {
var point int
var ace_flag bool
for i:=0;i<len(cards);i++ {
point += NumToPoint(cards[i].num)
if cards[i].num == 1 {
ace_flag = true
}
}
if ace_flag == true && point+10 < 21 {
point += 10
}
return point
}
func main() {
var user_cards []card
var cpu_cards []card
var deck = Initialize_Deck()
var burst_flag bool
deck, user_cards, cpu_cards = Initialize_game(deck, user_cards, cpu_cards)
deck, user_cards, burst_flag = Player_Turn(deck, user_cards)
if burst_flag == true {
} else {
deck, cpu_cards = Croupier_Turn(deck, cpu_cards)
fmt.Printf("あなたのポイント: %v\n", Print_Point(user_cards))
fmt.Printf("ディーラーのポイント: %v\n", Print_Point(cpu_cards))
Print_Result(user_cards, cpu_cards)
}
}
|
/*
* OpenAPI Petstore
*
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* API version: 1.0.0
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package petstoreserver
import (
"os"
)
type InlineObject1 struct {
// Additional data to pass to server
AdditionalMetadata string `json:"additionalMetadata,omitempty"`
// file to upload
File *os.File `json:"file,omitempty"`
}
|
package goexpr
import (
"bytes"
"fmt"
lls "github.com/emirpasic/gods/stacks/linkedliststack"
"regexp"
"sort"
"strconv"
"strings"
"unicode"
)
type Token struct {
Value string
Type string
}
type Engine struct {
priority map[string]int32
prefixSet map[string]PrefixOp
infixSet map[string]InfixOp
functionSet map[string]FunctionOp
funcArgs map[string]int
operaSet []string
}
func NewEngine() *Engine {
prefixSet := map[string]PrefixOp{}
priority := map[string]int32{}
infixSet := map[string]InfixOp{}
functionSet := map[string]FunctionOp{}
operaSet := []string{"(", ")", "[", "]", ","}
for k, v := range PrefixOpSet {
prefixSet[k] = v
operaSet = append(operaSet, k)
}
for k, v := range InfixOpSet {
infixSet[k] = v
operaSet = append(operaSet, k)
}
for k, v := range OpPriority {
priority[k] = v
}
return &Engine{
prefixSet: prefixSet,
priority: priority,
infixSet: infixSet,
functionSet: functionSet,
operaSet: operaSet,
funcArgs: map[string]int{},
}
}
func (en *Engine) AddFunc(fname string, op FunctionOp) {
en.functionSet[fname] = op
en.operaSet = append(en.operaSet, fname)
}
func (en *Engine) AddPrefix(fname string, op PrefixOp) {
en.prefixSet[fname] = op
en.operaSet = append(en.operaSet, fname)
}
func (en *Engine) AddInfix(fname string, priority int32, op InfixOp) {
en.infixSet[fname] = op
en.priority[fname] = priority
en.operaSet = append(en.operaSet, fname)
}
func (en *Engine) SetPriority(infix string, priority int32) {
en.priority[infix] = priority
}
func (en *Engine) Execute(expression string, args map[string]interface{}) interface{} {
exprs := en.expressionV2(expression)
numbs := lls.New()
operas := lls.New()
for _, expr := range exprs {
value := expr.Value
if numb, ok := GetNumber(value); ok {
numbs.Push(numb)
continue
}
if value == "true" {
numbs.Push(true)
continue
}
if value == "false" {
numbs.Push(false)
continue
}
if value != "'" && hasPreSufix(value, "'", "'") {
numbs.Push(value[1 : len(value)-1])
continue
}
if expr.Type == Args {
exprList := SpitExpr(value)
if top, _ := operas.Peek(); top != nil {
en.funcArgs[top.(*Token).Value] = len(exprList)
}
for _, tempExpr := range exprList {
numb := en.Execute(tempExpr, args)
numbs.Push(numb)
}
continue
}
if expr.Type == Array {
var array []interface{}
exprList := SpitExpr(value)
for _, tempExpr := range exprList {
numb := en.Execute(tempExpr, args)
array = append(array, numb)
}
numbs.Push(array)
continue
}
if value == BraktRight {
//计算括号内部的,直到计算到(
en.CalculateBract(operas, numbs)
continue
}
if Has(en.operaSet, value) {
en.PushCurOpera(expr, operas, numbs)
continue
}
numbs.Push(GetArg(value, args))
}
en.CalculateStack(operas, numbs)
result, _ := numbs.Pop()
return result
}
func hasPreSufix(exprs string, s string, e string) bool {
return strings.HasPrefix(exprs, s) && strings.HasSuffix(exprs, e)
}
func GetArg(path string, args map[string]interface{}) interface{} {
idx := strings.Index(path, ".")
if idx < 0 {
return args[path]
}
if args[path[:idx]] == nil {
return nil
}
tmpArgs, ok := args[path[:idx]].(map[string]interface{})
if !ok {
return nil
}
return GetArg(path[idx+1:], tmpArgs)
}
// 变量，数组，数字，字符串，操作符，括号
// 23+46*56-5*Add(-4-6) IN [1,2,3+4]
func (eng *Engine) expressionV2(exprs string) []*Token {
var idx = 0
var exprLen = len(exprs)
var exprList []*Token
sort.Slice(eng.operaSet, func(i, j int) bool {
return len(eng.operaSet[i]) > len(eng.operaSet[j])
})
for {
if idx >= exprLen {
break
}
item := rune(exprs[idx])
if unicode.IsSpace(item) {
idx++
continue
}
var pToken *Token
if len(exprList) > 0 {
pToken = exprList[len(exprList)-1]
}
if strings.HasPrefix(exprs[idx:], "'") {
end := strings.Index(exprs[idx+1:], "'")
str := exprs[idx : idx+end+2]
idx += len(str)
exprList = append(exprList, &Token{Value: str, Type: Value})
continue
}
if string(exprs[idx]) == ArrayLeft {
array := match(exprs[idx:], ArrayLeft, ArrayRight)
idx += len(array)
exprList = append(exprList, &Token{Value: array, Type: Array})
continue
}
if pToken != nil && pToken.Type == Func {
argExpr := match(exprs[idx:], BraktLeft, BraktRight)
idx += len(argExpr)
exprList = append(exprList, &Token{Value: argExpr, Type: Args})
continue
}
numbReg, _ := regexp.Compile(`^[0-9]+\.*[0-9]*`)
if numb := numbReg.FindString(exprs[idx:]); len(numb) > 0 {
idx += len(numb)
exprList = append(exprList, &Token{Value: numb, Type: Value})
continue
}
varReg, _ := regexp.Compile(`^[A-Za-z][A-Za-z0-9\._]*`)
if expr := varReg.FindString(exprs[idx:]); expr != "" {
// 变量名或者函数名或者一元操作或者二元操作
idx += len(expr)
exprList = append(exprList, eng.GetToken(pToken, expr))
continue
}
var opera string
for _, op := range eng.operaSet {
if strings.HasPrefix(exprs[idx:], op) {
opera = op
break
}
}
if opera != "" {
idx += len(opera)
exprList = append(exprList, eng.GetToken(pToken, opera))
continue
}
exprList = append(exprList, &Token{Value: exprs[idx:]})
break
}
return exprList
}
func (eng *Engine) GetToken(pToken *Token, expr string) *Token {
if expr == "" {
return nil
}
if eng.IsOpToken(pToken) && eng.prefixSet[expr] != nil {
return &Token{Value: expr, Type: PreOp}
}
if eng.functionSet[expr] != nil {
return &Token{Value: expr, Type: Func}
}
if eng.infixSet[expr] != nil {
return &Token{Value: expr, Type: InfxOp}
}
if eng.prefixSet[expr] != nil {
return &Token{Value: expr, Type: PreOp}
}
return &Token{Value: expr, Type: Variable}
}
func (eng *Engine) IsOpToken(tk *Token) bool {
if tk == nil {
return true
}
if tk.Type == Func || tk.Type == PreOp || tk.Type == InfxOp {
return true
}
if tk.Value == BraktLeft || tk.Value == ArrayLeft || tk.Value == ItemSpit {
return true
}
return false
}
func SpitExpr(exprs string) []string {
exprs = exprs[1 : len(exprs)-1]
var exprList []string
idx := 0
for {
if idx >= len(exprs) {
break
}
buf := &bytes.Buffer{}
jdx := idx
for {
if jdx >= len(exprs) {
break
}
if string(exprs[jdx]) == ItemSpit {
jdx++
break
}
if string(exprs[jdx]) == ArrayLeft {
exprStr := match(exprs[jdx:], ArrayLeft, ArrayRight)
jdx += len(exprStr)
buf.WriteString(exprStr)
continue
}
if string(exprs[jdx]) == BraktLeft {
exprStr := match(exprs[jdx:], BraktLeft, BraktRight)
jdx += len(exprStr)
buf.WriteString(exprStr)
continue
}
buf.WriteByte(exprs[jdx])
jdx++
}
exprStr := strings.TrimSpace(buf.String())
exprList = append(exprList, exprStr)
idx = jdx
}
return exprList
}
func GetNumber(str string) (float64, bool) {
number, err := strconv.ParseFloat(str, 64)
if err == nil {
return number, true
}
return 0, false
}
func (eng *Engine) CalculateStack(opStack, nbStack *lls.Stack) {
for {
top, _ := opStack.Peek()
if top == nil {
break
}
eng.CalculateTop(opStack, nbStack)
}
}
func (eng *Engine) CalculateBract(opStack, nbStack *lls.Stack) {
for {
top, _ := opStack.Peek()
if top == nil {
panic("you expr miss left (")
}
if top.(*Token).Value == BraktLeft {
opStack.Pop()
break
}
eng.CalculateTop(opStack, nbStack)
}
}
func (eng *Engine) PushCurOpera(curTk *Token, opStack, nbStack *lls.Stack) {
for {
top, _ := opStack.Peek()
if top == nil {
opStack.Push(curTk)
break
}
if curTk.Value == BraktLeft || curTk.Value == ArrayLeft {
opStack.Push(curTk)
break
}
topTk := top.(*Token)
if topTk.Value == BraktLeft || topTk.Value == ArrayLeft {
opStack.Push(curTk)
break
}
if curTk.Type == PreOp {
opStack.Push(curTk)
break
}
if curTk.Type == Func {
opStack.Push(curTk)
break
}
if topTk.Type == PreOp || topTk.Type == Func {
eng.CalculateTop(opStack, nbStack)
continue
}
topPty := eng.priority[topTk.Value]
curPty := eng.priority[curTk.Value]
if topPty < curPty {
opStack.Push(curTk)
break
}
eng.CalculateTop(opStack, nbStack)
}
}
func (eng *Engine) CalculateTop(opStack, nbStack *lls.Stack) {
top, _ := opStack.Peek()
if top == nil {
return
}
topTk := top.(*Token)
if topTk.Type == PreOp {
fun := eng.prefixSet[topTk.Value]
numb1, _ := nbStack.Pop()
result := fun(numb1)
nbStack.Push(result)
opStack.Pop()
return
}
if topTk.Type == InfxOp {
fun := eng.infixSet[topTk.Value]
numb1, _ := nbStack.Pop()
numb2, _ := nbStack.Pop()
result := fun(numb2, numb1)
nbStack.Push(result)
opStack.Pop()
return
}
if topTk.Type == Func {
fun := eng.functionSet[topTk.Value]
argCount := eng.funcArgs[topTk.Value]
var params = make([]interface{}, argCount)
for i := 0; i < argCount; i++ {
numb, _ := nbStack.Pop()
params[argCount-i-1] = numb
}
result := fun(params...)
nbStack.Push(result)
opStack.Pop()
return
}
panic(fmt.Sprintf("No find function '%v'", top))
}
func match(va string, left, right string) string {
lCount := 0
rCount := 0
for idx, v := range va {
if string(v) == left {
lCount++
}
if string(v) == right {
rCount++
}
if lCount == rCount {
return va[:idx+1]
}
}
if lCount > 0 {
panic("expr is miss right " + right)
}
return ""
}
func Has(array []string, va string) bool {
for _, v := range array {
if v == va {
return true
}
}
return false
}
|
package session
import (
"crypto/sha256"
"fmt"
"github.com/fasthttp/session/v2"
"github.com/authelia/authelia/v4/internal/utils"
)
// Serializer is a function that can serialize session information.
type Serializer interface {
Encode(src session.Dict) (data []byte, err error)
Decode(dst *session.Dict, src []byte) (err error)
}
// EncryptingSerializer a serializer encrypting the data with AES-GCM with 256-bit keys.
type EncryptingSerializer struct {
key [32]byte
}
// NewEncryptingSerializer return new encrypt instance.
func NewEncryptingSerializer(secret string) *EncryptingSerializer {
key := sha256.Sum256([]byte(secret))
return &EncryptingSerializer{key}
}
// Encode encode and encrypt session.
func (e *EncryptingSerializer) Encode(src session.Dict) (data []byte, err error) {
if len(src.KV) == 0 {
return nil, nil
}
dst, err := src.MarshalMsg(nil)
if err != nil {
return nil, fmt.Errorf("unable to marshal session: %v", err)
}
if data, err = utils.Encrypt(dst, &e.key); err != nil {
return nil, fmt.Errorf("unable to encrypt session: %v", err)
}
return data, nil
}
// Decode decrypt and decode session.
func (e *EncryptingSerializer) Decode(dst *session.Dict, src []byte) (err error) {
if len(src) == 0 {
return nil
}
for k := range dst.KV {
delete(dst.KV, k)
}
var data []byte
if data, err = utils.Decrypt(src, &e.key); err != nil {
return fmt.Errorf("unable to decrypt session: %s", err)
}
_, err = dst.UnmarshalMsg(data)
return err
}
|
package verifier
import (
"github.com/lf-edge/eve/pkg/pillar/types"
)
// wrappers to add objType for create. The Delete wrappers are merely
// for function name consistency
func handleAppImgModify(ctxArg interface{}, key string, configArg interface{}) {
vHandler.modify(ctxArg, types.AppImgObj, key, configArg)
}
func handleAppImgCreate(ctxArg interface{}, key string, configArg interface{}) {
vHandler.create(ctxArg, types.AppImgObj, key, configArg)
}
func handleAppImgDelete(ctxArg interface{}, key string, configArg interface{}) {
vHandler.delete(ctxArg, key, configArg)
}
|
/*
* @lc app=leetcode.cn id=121 lang=golang
*
* [121] 买卖股票的最佳时机
*/
// @lc code=start
package main
import "math"
import "fmt"
func maxProfit(prices []int) int {
minPrice := math.MaxInt64
maxProfit := 0
for i := 0 ; i < len(prices) ; i++ {
if prices[i] < minPrice {
minPrice = prices[i]
}
if prices[i] - minPrice > maxProfit {
maxProfit = prices[i] - minPrice
}
}
return maxProfit
}
// @lc code=end
func main(){
a := []int{7,1,5,3,6,4}
fmt.Printf("%v, %d\n", a, maxProfit(a))
a = []int{7,6,4,3,1}
fmt.Printf("%v, %d\n", a, maxProfit(a))
}
|
package main
import "fmt"
func main() {
//缓冲信道的长度是指信道中当前排队的元素个数。
//ch := make(chan string, 2) // 2 是指通道中元素的个数
//ch <- "naveen"
//ch <- "paul"
//ch <- "steve" //fatal error: all goroutines are asleep - deadlock!
//fmt.Println(<-ch)
//fmt.Println(<-ch)
//fmt.Println(<-ch)
//close(ch)
ch := make(chan string, 3)
ch <- "naveen"
ch <- "paul"
fmt.Println("capacity is", cap(ch))
fmt.Println("length is", len(ch))
fmt.Println("read value", <-ch)
fmt.Println("read value", <-ch)
fmt.Println("new length is ", len(ch))
}
|
package main
import (
"fmt"
"log"
"flag"
"os"
"github.com/kylelemons/go-gypsy/yaml"
"io/ioutil"
"github.com/ziutek/mymysql/mysql"
//_ "github.com/ziutek/mymysql/native"
_ "github.com/ziutek/mymysql/godrv"
"playGo/funDb"
)
var (
config *yaml.File
config_file = flag.String("conf", "./conf/database.yml", "the database.yml")
log_file_name = flag.String("log", "./log/server.log", "where does the log go?")
)
func initlogAndConfig() {
//create log
log_file, err := os.OpenFile(*log_file_name, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0777)
if err != nil {
panic(err)
}
log.SetOutput(log_file)
log.SetFlags(5)
//read the config and build config stuff
c_file, err := ioutil.ReadFile(*config_file)
if err != nil {
log.Panic(err)
}
config = yaml.Config(string(c_file))
}
func checkError(err error) {
if err != nil {
panic(err)
//os.Exit(1)
}
}
func checkedResult(rows []mysql.Row, res mysql.Result, err error) ([]mysql.Row,
mysql.Result) {
checkError(err)
return rows, res
}
func init(){
initlogAndConfig()
}
type Notices struct{
Id int
SubjectId int
SubjectType string
}
func main(){
//username, _ := config.Get("development.username")
//password, _ := config.Get("development.password")
//database, _ := config.Get("development.database")
//db := mysql.New("tcp", "", "127.0.0.1:3306", username, password, database)
//checkError(db.Connect())
//sel, err := db.Prepare("SELECT * FROM notices n where subject_id = ? LIMIT 0,1000")
//checkError(err)
//rows, res := checkedResult(sel.Exec(1))
//id := res.Map("id")
//subjectType := res.Map("subject_type")
//for _, row := range rows {
// fmt.Printf(row.Str(id))
// fmt.Printf(row[id])
// fmt.Printf(row.Str(subjectType))
//}
//_, _ = db.Query("select 1")
db, err := funDb.OpenMysql("mymysql", "tcp:localhost:3306*skyeye_development/root/admin123")
checkError(err)
var notices []Notices
qi := funDb.SqlQueryInfo{
Fields: "id, subject_id, subject_type",
Where: "id=2",
//Params: []interface{}{0},
Limit: 10,
Offset: 0,
Group: "",
Order: "id desc",
}
err1 := db.GetStructs(¬ices, qi)
checkError(err1)
fmt.Println(notices)
}
|
package session
import (
"fmt"
"time"
"strconv"
"strings"
"regexp"
"github.com/deepdeeppink/tgbot/state"
"github.com/deepdeeppink/tgbot/spells"
"github.com/deepdeeppink/tgbot/words"
"github.com/deepdeeppink/tgbot/bot"
"github.com/deepdeeppink/tgbot/cfg"
"github.com/deepdeeppink/tgbot/errs"
"github.com/deepdeeppink/tgbot/users"
"gopkg.in/telegram-bot-api.v4"
)
type Session struct {
Name string
ReadOn time.Time
C chan *words.Phrase
quit chan interface{}
Completed bool
}
const (
BC_PREFIX = "/broadcast " // TODO: Перенести в конфиг
)
var (
E = errs.E()
config = cfg.GetConfig()
book = *spells.GetSpellBook()
)
func NewSession(name string) *Session {
ch := make(chan *words.Phrase, 1)
quit := make(chan interface{})
go func() {
first := true
t := state.GetDefaultState()
spell := book[name]
updatedOn := time.Time{}
for {
select {
case ph := <- ch:
updated := t.Merge(ph.State)
if !updated && !first {
if time.Since(updatedOn) <= config.UpdTimeoutLimit * time.Second {
continue
}
updatedOn = time.Now()
go func(msg *tgbotapi.Message, t state.State, spell *spells.Spell) {
// TODO: Заменить кодом на bot.Update
B := bot.Get()
placeholder := make(chan int, 2)
snail := make(chan interface{})
go func() {
pkg := tgbotapi.NewMessage(int64(msg.From.ID), config.Scripts["loading"])
pkg.ParseMode = "Markdown"
pkg.DisableNotification = true
pkg.ReplyToMessageID = msg.MessageID
sent, _ := B.Send(pkg)
placeholder <- sent.MessageID
time.Sleep(config.SnailTime * time.Second)
snail <- nil
}()
go func() {
<-snail
mid := <- placeholder
if mid > 0 {
ec := tgbotapi.NewEditMessageText(msg.Chat.ID, mid, config.Scripts["snail"])
ec.ParseMode = "Markdown"
go func() {
_, err := B.Send(ec); E <- err
}()
placeholder <- mid
}
}()
(*spell).Cast(&t)
mid := <-placeholder
close(placeholder)
line := (*spell).Read(&t)
ec := tgbotapi.NewEditMessageText(msg.Chat.ID, mid, line)
ec.ParseMode = "Markdown"
go func() {
_, err := B.Send(ec); E <- err
}()
}(ph.Message, *t, &spell)
} else {
line := spell.Read(t)
if spell.IsFile() {
bot.GetMsg(ph.Message).ReplFile(line)
} else {
bot.GetMsg(ph.Message).Repl(line)
}
}
first = false
time.Sleep(200 * time.Millisecond) // В одной сессии бот не будет отвечать слищком быстро
case <- quit:
close(ch)
close(quit)
return
}
}
}()
return &Session{
Name: name,
ReadOn: time.Now(),
C: ch,
quit: quit,
Completed: false,
}
}
func NewBroadcast() *Session {
ch := make(chan *words.Phrase, 1)
quit := make(chan interface{})
s := Session{
ReadOn: time.Now(),
C: ch,
quit: quit,
Completed: false,
}
go func() {
num := regexp.MustCompile(`^\d+`)
var broadcasted string
var level users.Level
proposed := false
for {
select {
case ph := <- ch:
msg := ph.Message
if !proposed {
level, _ := strconv.Atoi(num.FindString(msg.Text[len(BC_PREFIX):])) // ошибка = группа не укзаана = 0
broadcasted = strings.Replace(
msg.Text[len(BC_PREFIX):],
fmt.Sprintf("%d ", level),
"",
-1,
)
bot.GetMsg(msg).Confirm(broadcasted)
proposed = true
continue
}
if msg.Text == bot.BC_CONFIRM {
go bot.Broadcast(broadcasted, level)
}
s.Completed = true
case <- quit:
close(ch)
close(quit)
return
}
}
}()
return &s
}
func (s *Session) Close() {
s.quit <- nil
}
|
package main
import (
"github.com/blablacar/attributes-merger/attributes"
"io/ioutil"
)
// TODO - lire fichier de conf
// trapper la variable d'environnement
func main() {
// Get Option Flags
fgs := newFlags()
in := attributes.NewInputs(fgs.input_dir)
// initialize input files list
err := in.ListFiles()
if err != nil {
panic(err)
}
res := []string{}
for _, file := range in.Files {
res = append(res, in.Directory + file)
}
out := attributes.Merge(fgs.confd_env, res)
err = ioutil.WriteFile("attributes.json", []byte(out), 0777)
if err != nil {
panic(err)
}
}
|
/*
You are given a list of 999,998 integers, which include all the integers between 1 and 1,000,000 (inclusive on both ends) in some unknown order, with the exception of two numbers which have been removed.
By making only one pass through the data and using only a constant amount of memory (i.e. O(1) memory usage), can you figure out what two numbers have been excluded?
Note that since you are only allowed one pass through the data, you are not allowed to sort the list!
EDIT: clarified problem
Thanks to Cosmologicon for suggesting this problem at r/dailyprogrammer_ideas? Do you have a problem you think would be good for us? Why not head over there and suggest it?
*/
package main
import (
"fmt"
"math"
"math/rand"
"time"
)
func main() {
rand.Seed(time.Now().UnixNano())
test(1e6)
}
func assert(x bool) {
if !x {
panic("assertion failed")
}
}
func test(n int) {
if n < 3 {
return
}
v := perm(n)
x, y := missing(v[:n-2])
fmt.Println(x, y)
assert(max(x, y) == max(v[n-1], v[n-2]))
assert(min(x, y) == min(v[n-1], v[n-2]))
}
/*
The idea is to use the sum of natural numbers and sum of squares formula to calculate the total number.
If we subtract all the numbers in the list out from the total number, the remaining values represents the constraints that the two missing number have to add up to.
This leads to a quadratic equation where the roots are the missing numbers.
*/
func missing(v []int64) (x, y int64) {
n := int64(len(v)) + 2
if n < 3 {
return
}
a := n * (n + 1) / 2
b := n * (n + 1) * (2*n + 1) / 6
for i := range v {
a -= v[i]
b -= v[i] * v[i]
}
s := isqrt(2*b - a*a)
x = (a + s) / 2
y = (a - s) / 2
return
}
func perm(n int) []int64 {
p := rand.Perm(n)
r := make([]int64, n)
for i := range r {
r[i] = int64(p[i]) + 1
}
return r
}
func isqrt(x int64) int64 {
return int64(math.Sqrt(float64(x)))
}
func max(a, b int64) int64 {
if a > b {
return a
}
return b
}
func min(a, b int64) int64 {
if a < b {
return a
}
return b
}
|
package main
import (
_ "encoding/json"
"fmt"
"strings"
"time"
"github.com/pquerna/ffjson/ffjson"
)
type Report struct {
ProjectName string `json: "ProjectName"`
ProjectNo string `json: "ProjectNo"`
Name string `json: "Name"`
Description string `json: "Description"`
Issue string `json: "Issue"`
Planning string `json: "Planning"`
LogTime string `json: "LogTime"`
}
// text
func format2txt(rows *string) (lines string) {
lines = strings.Replace(*rows, "/", "\t", -1)
fmt.Println(lines)
return
}
// json
func format2json(rows *string, sendtime int) (toj string) {
lines := strings.Split(*rows, "/")
if len(lines) != 6 {
fmt.Println("Error format: ", *rows)
}
var logtime string
logtime = time.Unix(int64(sendtime), 0).Format("2006-01-02 15:04:05")
var rpt *Report = &Report{
ProjectName: lines[0],
ProjectNo: lines[1],
Name: lines[2],
Description: lines[3],
Issue: lines[4],
Planning: lines[5],
LogTime: logtime,
}
j, err := ffjson.Marshal(&rpt)
if err != nil {
panic(err)
}
toj = string(j)
fmt.Println(toj)
return
}
|
// Copyright 2016 CoreOS, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package main
import (
"fmt"
"os"
"github.com/spf13/cobra"
)
// buildtime and githash are being defined at linking.
var buildtime = "Unknown build time"
var githash = "Unknow hash"
var versionCommand = &cobra.Command{
Use: "version",
Short: "print the current version",
Run: showVersion,
}
func showVersion(_ *cobra.Command, _ []string) {
fmt.Printf("Build %s (%s)\n", githash, buildtime)
os.Exit(0)
}
|
package response
import(
"github.com/shrikar007/customer-rest-api/structs"
"net/http"
)
type Getallstruct struct {
*structs.Customers
}
func (Getallstruct) Render(w http.ResponseWriter, r *http.Request) error {
return nil
}
func Getallresponse(customers *structs.Customers) *Getallstruct{
return &Getallstruct{Customers: customers}
}
|
package pov
import (
"time"
"github.com/qlcchain/go-qlc/common"
"github.com/qlcchain/go-qlc/common/types"
"github.com/qlcchain/go-qlc/p2p"
"github.com/qlcchain/go-qlc/p2p/protos"
)
const (
maxSyncBlockInQue = 500
)
type PovSyncBlock struct {
PeerID string
Height uint64
Block *types.PovBlock
TxExists map[types.Hash]struct{}
}
func (ss *PovSyncer) syncLoop() {
forceTicker := time.NewTicker(forceSyncTimeInSec * time.Second)
checkSyncTicker := time.NewTicker(1 * time.Second)
checkChainTicker := time.NewTicker(10 * time.Second)
requestSyncTicker := time.NewTicker(5 * time.Second)
checkSyncPeerTicker := time.NewTicker(10 * time.Second)
defer forceTicker.Stop()
defer checkSyncTicker.Stop()
defer checkChainTicker.Stop()
for {
select {
case <-ss.quitCh:
return
case <-forceTicker.C:
ss.onPeriodicSyncTimer()
case <-checkSyncTicker.C:
ss.onCheckSyncBlockTimer()
case <-checkChainTicker.C:
ss.onCheckChainTimer()
case <-requestSyncTicker.C:
ss.onRequestSyncTimer()
case <-checkSyncPeerTicker.C:
ss.onSyncPeerTimer()
}
}
//ss.logger.Infof("exit pov sync loop")
}
func (ss *PovSyncer) onPeriodicSyncTimer() {
if ss.inSyncing.Load() == true {
return
}
latestBlock := ss.chain.LatestBlock()
if latestBlock == nil {
ss.logger.Errorf("failed to get latest block")
return
}
latestTD := ss.chain.GetBlockTDByHash(latestBlock.GetHash())
if latestTD == nil {
ss.logger.Errorf("failed to get latest td")
return
}
bestPeer := ss.GetBestPeer("")
if bestPeer == nil {
ss.logger.Warnf("all peers are gone")
return
}
syncOver := false
if latestTD.Cmp(bestPeer.currentTD) >= 0 {
syncOver = true
} else if ss.absDiffHeight(latestBlock.GetHeight(), bestPeer.currentHeight) <= 3 {
syncOver = true
}
if syncOver {
ss.setInitState(common.Syncing)
ss.setInitState(common.Syncdone)
return
}
topPeers := ss.GetBestPeers(5)
ss.logger.Infof("TopPeers: %d", len(topPeers))
for _, peer := range topPeers {
ss.logger.Infof("%s-%d-%s", peer.peerID, peer.currentHeight, peer.currentTD)
}
ss.inSyncing.Store(true)
ss.setInitState(common.Syncing)
ss.syncWithPeer(bestPeer)
}
func (ss *PovSyncer) onSyncPeerTimer() {
if ss.inSyncing.Load() != true {
return
}
syncErr := false
syncPeer := ss.FindPeerWithStatus(ss.syncPeerID, peerStatusGood)
if syncPeer == nil {
ss.logger.Infof("sync peer %s is lost", ss.syncPeerID)
syncErr = true
} else if syncPeer.waitSyncRspMsg {
if syncPeer.lastSyncReqTime.Add(time.Minute).Before(time.Now()) {
ss.logger.Infof("sync peer %s may be too slow", ss.syncPeerID)
syncPeer.status = peerStatusSlow
syncErr = true
}
}
if syncErr {
ss.logger.Warnf("sync terminated with peer %s", ss.syncPeerID)
ss.inSyncing.Store(false)
ss.resetSyncPeer(syncPeer)
}
}
func (ss *PovSyncer) onRequestSyncTimer() {
if ss.inSyncing.Load() != true {
return
}
syncPeer := ss.FindPeerWithStatus(ss.syncPeerID, peerStatusGood)
if syncPeer == nil {
ss.logger.Warnf("request syncing blocks but peer %s is gone", ss.syncPeerID)
return
}
if syncPeer.waitLocatorRsp {
ss.requestSyncingBlocks(syncPeer, true)
} else {
ss.requestSyncingBlocks(syncPeer, false)
}
}
func (ss *PovSyncer) onCheckChainTimer() {
if ss.inSyncing.Load() != true {
return
}
latestBlock := ss.chain.LatestBlock()
if latestBlock == nil {
ss.logger.Errorf("failed to get latest block")
return
}
if ss.syncCurHeight >= ss.syncToHeight && latestBlock.GetHeight() >= ss.syncToHeight {
ss.logger.Infof("sync done, current height:%d", latestBlock.Height)
ss.inSyncing.Store(false)
ss.setInitState(common.Syncdone)
return
}
ss.logger.Infof("syncCurHeight:%d, syncRcvHeight:%d, syncToHeight:%d, chainHeight:%d",
ss.syncCurHeight, ss.syncRcvHeight, ss.syncToHeight, latestBlock.Height)
}
func (ss *PovSyncer) syncWithPeer(peer *PovSyncPeer) {
ss.syncPeerID = peer.peerID
ss.syncToHeight = peer.currentHeight
ss.syncCurHeight = 0
ss.syncRcvHeight = 0
ss.syncReqHeight = 0
ss.syncBlocks = make(map[uint64]*PovSyncBlock)
ss.logger.Infof("sync starting with peer %s height %d", peer.peerID, peer.currentHeight)
ss.requestSyncingBlocks(peer, true)
}
func (ss *PovSyncer) resetSyncPeer(peer *PovSyncPeer) {
ss.syncPeerID = ""
ss.syncToHeight = 0
ss.syncCurHeight = 0
ss.syncRcvHeight = 0
ss.syncReqHeight = 0
ss.syncBlocks = nil
if peer != nil {
peer.waitSyncRspMsg = false
peer.lastSyncReqTime = time.Now()
peer.waitLocatorRsp = false
}
}
func (ss *PovSyncer) requestSyncingBlocks(syncPeer *PovSyncPeer, useLocator bool) {
if ss.inSyncing.Load() != true {
return
}
if len(ss.syncBlocks) >= maxSyncBlockInQue {
ss.logger.Warnf("request syncing blocks but queue %d is full", len(ss.syncBlocks))
return
}
if syncPeer.waitSyncRspMsg {
if syncPeer.lastSyncReqTime.Add(15 * time.Second).After(time.Now()) {
return
}
}
req := new(protos.PovBulkPullReq)
req.Reason = protos.PovReasonSync
req.Count = maxSyncBlockPerReq
if useLocator {
req.Locators = ss.chain.GetBlockLocator(types.ZeroHash)
} else {
req.StartHeight = ss.syncRcvHeight + 1
if req.StartHeight > ss.syncToHeight {
return
}
}
if useLocator {
ss.logger.Infof("request syncing blocks use locators %d with peer %s", len(req.Locators), ss.syncPeerID)
} else {
ss.logger.Infof("request syncing blocks use height %d with peer %s", req.StartHeight, ss.syncPeerID)
}
ss.eb.Publish(common.EventSendMsgToSingle, p2p.PovBulkPullReq, req, ss.syncPeerID)
syncPeer.lastSyncReqTime = time.Now()
syncPeer.waitSyncRspMsg = true
if useLocator {
syncPeer.waitLocatorRsp = true
}
ss.syncReqHeight = req.StartHeight
}
func (ss *PovSyncer) onCheckSyncBlockTimer() {
if ss.inSyncing.Load() != true {
return
}
for height := ss.syncCurHeight; height <= ss.syncRcvHeight; height++ {
syncBlk := ss.syncBlocks[height]
if syncBlk == nil || syncBlk.Block == nil {
return
}
hasTxPend := ss.checkSyncBlock(syncBlk)
if hasTxPend {
return
}
ss.eb.Publish(common.EventPovRecvBlock, syncBlk.Block, types.PovBlockFromRemoteSync, syncBlk.PeerID)
ss.syncCurHeight = height + 1
delete(ss.syncBlocks, height)
}
}
func (ss *PovSyncer) addSyncBlock(block *types.PovBlock, peer *PovSyncPeer) {
if ss.inSyncing.Load() != true {
return
}
syncBlk := ss.syncBlocks[block.GetHeight()]
if syncBlk == nil {
syncBlk = &PovSyncBlock{Height: block.GetHeight(), Block: block, PeerID: peer.peerID}
syncBlk.TxExists = make(map[types.Hash]struct{})
ss.syncBlocks[block.GetHeight()] = syncBlk
} else if syncBlk.Block != nil {
if syncBlk.Block.GetHash() != block.GetHash() {
syncBlk.Block = block
}
} else {
syncBlk.Block = block
}
if peer.waitLocatorRsp {
peer.waitLocatorRsp = false
ss.syncCurHeight = block.GetHeight()
ss.syncRcvHeight = block.GetHeight()
ss.logger.Infof("got locator response, syncCurHeight %d", ss.syncCurHeight)
} else {
if block.GetHeight() == (ss.syncRcvHeight + 1) {
ss.syncRcvHeight = block.GetHeight()
}
}
}
func (ss *PovSyncer) checkSyncBlock(syncBlk *PovSyncBlock) bool {
var reqTxHashes []*types.Hash
for _, tx := range syncBlk.Block.Transactions {
txHash := tx.GetHash()
ok, _ := ss.ledger.HasStateBlock(txHash)
if ok {
syncBlk.TxExists[txHash] = struct{}{}
} else {
reqTxHashes = append(reqTxHashes, &txHash)
}
}
if uint32(len(syncBlk.TxExists)) >= syncBlk.Block.GetTxNum() {
return false
}
if len(reqTxHashes) > 0 {
ss.requestTxsByHashes(reqTxHashes, syncBlk.PeerID)
}
return true
}
|
package main
import (
"fmt"
"github.com/gtfierro/xboswave/ingester/types"
xbospb "github.com/gtfierro/xboswave/proto"
)
func has_device(msg xbospb.XBOS) bool {
return msg.XBOSIoTDeviceState.WeatherStation != nil
}
var device_units = map[string]string{
"time": "seconds",
"icon": "",
"nearestStormDistance": "miles",
"nearestStormBearing": "degrees",
"precipIntensity": "inches per hour",
"precipIntensityError": "",
"precipProbability": "",
"precipType": "",
"temperature": "F",
"apparentTemperature": "F",
"dewPoint": "F",
"humidity": "",
"pressure": "millibars",
"windSpeed": "miles per hour",
"windGust": "miles per hour",
"windBearing": "degree",
"cloudCover": "",
"uvIndex": "miles",
"visibility": "",
"ozone": "Dobson",
}
var device_lookup = map[string]func(msg xbospb.XBOS) (float64, bool){
"time": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.Time != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.Time.Value), true
}
return 0, false
},
"nearestStormDistance": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.NearestStormDistance != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.NearestStormDistance.Value), true
}
return 0, false
},
"nearestStormBearing": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.NearestStormBearing != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.NearestStormBearing.Value), true
}
return 0, false
},
"precipIntensity": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.PrecipIntensity != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.PrecipIntensity.Value), true
}
return 0, false
},
"precipIntensityError": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.PrecipIntensityError != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.PrecipIntensityError.Value), true
}
return 0, false
},
"precipProbability": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.PrecipProbability != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.PrecipProbability.Value), true
}
return 0, false
},
"temperature": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.Temperature != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.Temperature.Value), true
}
return 0, false
},
"apparentTemperature": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.ApparentTemperature != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.ApparentTemperature.Value), true
}
return 0, false
},
"dewPoint": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.DewPoint != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.DewPoint.Value), true
}
return 0, false
},
"humidity": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.Humidity != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.Humidity.Value), true
}
return 0, false
},
"pressure": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.Pressure != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.Pressure.Value), true
}
return 0, false
},
"windSpeed": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.WindSpeed != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.WindSpeed.Value), true
}
return 0, false
},
"windGust": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.WindGust != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.WindGust.Value), true
}
return 0, false
},
"windBearing": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.WindBearing != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.WindBearing.Value), true
}
return 0, false
},
"cloudCover": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.CloudCover != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.CloudCover.Value), true
}
return 0, false
},
"uvIndex": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.UvIndex != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.UvIndex.Value), true
}
return 0, false
},
"visibility": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.Visibility != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.Visibility.Value), true
}
return 0, false
},
"ozone": func(msg xbospb.XBOS) (float64, bool) {
if has_device(msg) && msg.XBOSIoTDeviceState.WeatherStation.Ozone != nil {
return float64(msg.XBOSIoTDeviceState.WeatherStation.Ozone.Value), true
}
return 0, false
},
}
func build_device(uri types.SubscriptionURI, name string, msg xbospb.XBOS) types.ExtractedTimeseries {
if extractfunc, found := device_lookup[name]; found {
if value, found := extractfunc(msg); found {
var extracted types.ExtractedTimeseries
time := int64(msg.XBOSIoTDeviceState.Time)
extracted.Values = append(extracted.Values, value)
extracted.Times = append(extracted.Times, time)
extracted.UUID = types.GenerateUUID(uri, []byte(name))
extracted.Collection = fmt.Sprintf("xbos/%s", uri.Resource)
extracted.Tags = map[string]string{
"unit": device_units[name],
"name": name,
}
return extracted
}
}
return types.ExtractedTimeseries{}
}
func Extract(uri types.SubscriptionURI, msg xbospb.XBOS, add func(types.ExtractedTimeseries) error) error {
if msg.XBOSIoTDeviceState != nil {
if has_device(msg) {
for name := range device_lookup {
extracted := build_device(uri, name, msg)
if err := add(extracted); err != nil {
return err
}
}
}
}
return nil
}
|
package solve
import lane "gopkg.in/oleiade/lane.v1"
func findShortestPath(start string, end string, graph map[string][]string) []string {
dq := lane.NewDeque()
visited := make(map[string]bool)
dq.Append([]string{start})
for {
if dq.Empty() {
break
} else {
path := dq.Shift()
if p, ok := path.([]string); ok {
word := p[len(p)-1]
visited[word] = true
if word == end {
return p
}
for _, adj := range graph[word] {
if _, found := visited[adj]; !found {
newPath := make([]string, len(p))
copy(newPath, p)
newPath = append(newPath, adj)
dq.Append(newPath)
}
}
}
}
}
return nil
}
func reachable(start string, graph map[string][]string) []string {
dq := lane.NewDeque()
visited := make(map[string]bool)
dq.Append([]string{start})
for {
if dq.Empty() {
break
} else {
path := dq.Shift()
if p, ok := path.([]string); ok {
word := p[len(p)-1]
visited[word] = true
for _, adj := range graph[word] {
if _, found := visited[adj]; !found {
newPath := make([]string, len(p))
copy(newPath, p)
newPath = append(newPath, adj)
dq.Append(newPath)
}
}
}
}
}
reachableWords := make([]string, 0, len(visited))
for word := range visited {
reachableWords = append(reachableWords, word)
}
return reachableWords
}
func findLongestPath(start string, end string, graph map[string][]string) []string {
dq := lane.NewDeque()
visited := make(map[string]bool)
dq.Append([]string{start})
for {
if dq.Empty() {
break
} else {
path := dq.Pop()
if p, ok := path.([]string); ok {
word := p[len(p)-1]
visited[word] = true
if word == end {
return p
}
for _, adj := range graph[word] {
if _, found := visited[adj]; !found {
newPath := make([]string, len(p))
copy(newPath, p)
newPath = append(newPath, adj)
dq.Append(newPath)
}
}
}
}
}
return nil
}
|
package shared
import (
"testing"
"github.com/cli/cli/v2/api"
"github.com/cli/cli/v2/internal/ghrepo"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/cli/cli/v2/pkg/prompt"
"github.com/stretchr/testify/assert"
)
type metadataFetcher struct {
metadataResult *api.RepoMetadataResult
}
func (mf *metadataFetcher) RepoMetadataFetch(input api.RepoMetadataInput) (*api.RepoMetadataResult, error) {
return mf.metadataResult, nil
}
func TestMetadataSurvey_selectAll(t *testing.T) {
ios, _, stdout, stderr := iostreams.Test()
repo := ghrepo.New("OWNER", "REPO")
fetcher := &metadataFetcher{
metadataResult: &api.RepoMetadataResult{
AssignableUsers: []api.RepoAssignee{
{Login: "hubot"},
{Login: "monalisa"},
},
Labels: []api.RepoLabel{
{Name: "help wanted"},
{Name: "good first issue"},
},
Projects: []api.RepoProject{
{Name: "Huge Refactoring"},
{Name: "The road to 1.0"},
},
Milestones: []api.RepoMilestone{
{Title: "1.2 patch release"},
},
},
}
//nolint:staticcheck // SA1019: prompt.InitAskStubber is deprecated: use NewAskStubber
as, restoreAsk := prompt.InitAskStubber()
defer restoreAsk()
//nolint:staticcheck // SA1019: as.Stub is deprecated: use StubPrompt
as.Stub([]*prompt.QuestionStub{
{
Name: "metadata",
Value: []string{"Labels", "Projects", "Assignees", "Reviewers", "Milestone"},
},
})
//nolint:staticcheck // SA1019: as.Stub is deprecated: use StubPrompt
as.Stub([]*prompt.QuestionStub{
{
Name: "reviewers",
Value: []string{"monalisa"},
},
{
Name: "assignees",
Value: []string{"hubot"},
},
{
Name: "labels",
Value: []string{"good first issue"},
},
{
Name: "projects",
Value: []string{"The road to 1.0"},
},
{
Name: "milestone",
Value: "(none)",
},
})
state := &IssueMetadataState{
Assignees: []string{"hubot"},
}
err := MetadataSurvey(ios, repo, fetcher, state)
assert.NoError(t, err)
assert.Equal(t, "", stdout.String())
assert.Equal(t, "", stderr.String())
assert.Equal(t, []string{"hubot"}, state.Assignees)
assert.Equal(t, []string{"monalisa"}, state.Reviewers)
assert.Equal(t, []string{"good first issue"}, state.Labels)
assert.Equal(t, []string{"The road to 1.0"}, state.Projects)
assert.Equal(t, []string{}, state.Milestones)
}
func TestMetadataSurvey_keepExisting(t *testing.T) {
ios, _, stdout, stderr := iostreams.Test()
repo := ghrepo.New("OWNER", "REPO")
fetcher := &metadataFetcher{
metadataResult: &api.RepoMetadataResult{
Labels: []api.RepoLabel{
{Name: "help wanted"},
{Name: "good first issue"},
},
Projects: []api.RepoProject{
{Name: "Huge Refactoring"},
{Name: "The road to 1.0"},
},
},
}
//nolint:staticcheck // SA1019: prompt.InitAskStubber is deprecated: use NewAskStubber
as, restoreAsk := prompt.InitAskStubber()
defer restoreAsk()
//nolint:staticcheck // SA1019: as.Stub is deprecated: use StubPrompt
as.Stub([]*prompt.QuestionStub{
{
Name: "metadata",
Value: []string{"Labels", "Projects"},
},
})
//nolint:staticcheck // SA1019: as.Stub is deprecated: use StubPrompt
as.Stub([]*prompt.QuestionStub{
{
Name: "labels",
Value: []string{"good first issue"},
},
{
Name: "projects",
Value: []string{"The road to 1.0"},
},
})
state := &IssueMetadataState{
Assignees: []string{"hubot"},
}
err := MetadataSurvey(ios, repo, fetcher, state)
assert.NoError(t, err)
assert.Equal(t, "", stdout.String())
assert.Equal(t, "", stderr.String())
assert.Equal(t, []string{"hubot"}, state.Assignees)
assert.Equal(t, []string{"good first issue"}, state.Labels)
assert.Equal(t, []string{"The road to 1.0"}, state.Projects)
}
|
package controller
import (
"encoding/json"
"log"
"net/http"
"strings"
"github.com/galenguyer/retina/storage"
)
func StartServer() {
fileServer := http.FileServer(http.Dir("./web/app/build/"))
http.HandleFunc("/api/v1/hour", GetLastHour)
http.Handle("/", http.StripPrefix(strings.TrimRight("/", "/"), fileServer))
log.Println("starting webserver on port 8000")
http.ListenAndServe(":8000", nil)
}
func GetLastHour(w http.ResponseWriter, r *http.Request) {
res := storage.GetLastHour()
json.NewEncoder(w).Encode(res)
}
|
package openstack
import (
"errors"
"fmt"
"regexp"
"strings"
"time"
"github.com/gophercloud/gophercloud"
"github.com/gophercloud/gophercloud/openstack/blockstorage/v3/snapshots"
"github.com/gophercloud/gophercloud/openstack/blockstorage/v3/volumes"
"github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/servergroups"
"github.com/gophercloud/gophercloud/openstack/compute/v2/servers"
"github.com/gophercloud/gophercloud/openstack/imageservice/v2/images"
"github.com/gophercloud/gophercloud/openstack/loadbalancer/v2/apiversions"
"github.com/gophercloud/gophercloud/openstack/loadbalancer/v2/loadbalancers"
"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/attributestags"
"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/layer3/floatingips"
"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/layer3/routers"
sg "github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/security/groups"
"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/subnetpools"
"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/trunks"
"github.com/gophercloud/gophercloud/openstack/networking/v2/networks"
"github.com/gophercloud/gophercloud/openstack/networking/v2/ports"
"github.com/gophercloud/gophercloud/openstack/networking/v2/subnets"
"github.com/gophercloud/gophercloud/openstack/objectstorage/v1/containers"
"github.com/gophercloud/gophercloud/openstack/objectstorage/v1/objects"
"github.com/gophercloud/gophercloud/openstack/sharedfilesystems/v2/shares"
sharesnapshots "github.com/gophercloud/gophercloud/openstack/sharedfilesystems/v2/snapshots"
"github.com/gophercloud/gophercloud/pagination"
"github.com/gophercloud/utils/openstack/clientconfig"
"github.com/sirupsen/logrus"
k8serrors "k8s.io/apimachinery/pkg/util/errors"
"k8s.io/apimachinery/pkg/util/wait"
"github.com/openshift/installer/pkg/destroy/providers"
"github.com/openshift/installer/pkg/types"
openstackdefaults "github.com/openshift/installer/pkg/types/openstack/defaults"
"github.com/openshift/installer/pkg/types/openstack/validation/networkextensions"
)
const (
cinderCSIClusterIDKey = "cinder.csi.openstack.org/cluster"
manilaCSIClusterIDKey = "manila.csi.openstack.org/cluster"
minOctaviaVersionWithTagSupport = "v2.5"
cloudProviderSGNamePattern = `^lb-sg-[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}`
)
// Filter holds the key/value pairs for the tags we will be matching
// against.
type Filter map[string]string
// ObjectWithTags is a generic way to represent an OpenStack object
// and its tags so that filtering objects client-side can be done in a generic
// way.
//
// Note we use UUID not Name as not all OpenStack services require a unique
// name.
type ObjectWithTags struct {
ID string
Tags map[string]string
}
// deleteFunc type is the interface a function needs to implement to be called as a goroutine.
// The (bool, error) return type mimics wait.ExponentialBackoff where the bool indicates successful
// completion, and the error is for unrecoverable errors.
type deleteFunc func(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error)
// ClusterUninstaller holds the various options for the cluster we want to delete.
type ClusterUninstaller struct {
// Cloud is the cloud name as set in clouds.yml
Cloud string
// Filter contains the openshiftClusterID to filter tags
Filter Filter
// InfraID contains unique cluster identifier
InfraID string
Logger logrus.FieldLogger
}
// New returns an OpenStack destroyer from ClusterMetadata.
func New(logger logrus.FieldLogger, metadata *types.ClusterMetadata) (providers.Destroyer, error) {
return &ClusterUninstaller{
Cloud: metadata.ClusterPlatformMetadata.OpenStack.Cloud,
Filter: metadata.ClusterPlatformMetadata.OpenStack.Identifier,
InfraID: metadata.InfraID,
Logger: logger,
}, nil
}
// Run is the entrypoint to start the uninstall process.
func (o *ClusterUninstaller) Run() (*types.ClusterQuota, error) {
opts := openstackdefaults.DefaultClientOpts(o.Cloud)
// Check that the cloud has the minimum requirements for the destroy
// script to work properly.
if err := validateCloud(opts, o.Logger); err != nil {
return nil, err
}
// deleteFuncs contains the functions that will be launched as
// goroutines.
deleteFuncs := map[string]deleteFunc{
"cleanVIPsPorts": cleanVIPsPorts,
"deleteServers": deleteServers,
"deleteServerGroups": deleteServerGroups,
"deleteTrunks": deleteTrunks,
"deleteLoadBalancers": deleteLoadBalancers,
"deletePorts": deletePortsByFilter,
"deleteSecurityGroups": deleteSecurityGroups,
"clearRouterInterfaces": clearRouterInterfaces,
"deleteSubnets": deleteSubnets,
"deleteSubnetPools": deleteSubnetPools,
"deleteNetworks": deleteNetworks,
"deleteContainers": deleteContainers,
"deleteVolumes": deleteVolumes,
"deleteShares": deleteShares,
"deleteVolumeSnapshots": deleteVolumeSnapshots,
"deleteFloatingIPs": deleteFloatingIPs,
"deleteImages": deleteImages,
}
returnChannel := make(chan string)
// launch goroutines
for name, function := range deleteFuncs {
go deleteRunner(name, function, opts, o.Filter, o.Logger, returnChannel)
}
// wait for them to finish
for i := 0; i < len(deleteFuncs); i++ {
res := <-returnChannel
o.Logger.Debugf("goroutine %v complete", res)
}
// we want to remove routers as the last thing as it requires detaching the
// FIPs and that will cause it impossible to track which FIPs are tied to
// LBs being deleted.
err := deleteRouterRunner(opts, o.Filter, o.Logger)
if err != nil {
return nil, err
}
// we need to untag the custom network if it was provided by the user
err = untagRunner(opts, o.InfraID, o.Logger)
if err != nil {
return nil, err
}
return nil, nil
}
func deleteRunner(deleteFuncName string, dFunction deleteFunc, opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger, channel chan string) {
backoffSettings := wait.Backoff{
Duration: time.Second * 15,
Factor: 1.3,
Steps: 25,
}
err := wait.ExponentialBackoff(backoffSettings, func() (bool, error) {
return dFunction(opts, filter, logger)
})
if err != nil {
logger.Fatalf("Unrecoverable error/timed out: %v", err)
}
// record that the goroutine has run to completion
channel <- deleteFuncName
}
// filterObjects will do client-side filtering given an appropriately filled out
// list of ObjectWithTags.
func filterObjects(osObjects []ObjectWithTags, filters Filter) []ObjectWithTags {
objectsWithTags := []ObjectWithTags{}
filteredObjects := []ObjectWithTags{}
// first find the objects that have all the desired tags
for _, object := range osObjects {
allTagsFound := true
for key := range filters {
if _, ok := object.Tags[key]; !ok {
// doesn't have one of the tags we're looking for so skip it
allTagsFound = false
break
}
}
if allTagsFound {
objectsWithTags = append(objectsWithTags, object)
}
}
// now check that the values match
for _, object := range objectsWithTags {
valuesMatch := true
for key, val := range filters {
if object.Tags[key] != val {
valuesMatch = false
break
}
}
if valuesMatch {
filteredObjects = append(filteredObjects, object)
}
}
return filteredObjects
}
func filterTags(filters Filter) []string {
tags := []string{}
for k, v := range filters {
tags = append(tags, strings.Join([]string{k, v}, "="))
}
return tags
}
func deleteServers(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack servers")
defer logger.Debugf("Exiting deleting openstack servers")
conn, err := clientconfig.NewServiceClient("compute", opts)
if err != nil {
logger.Error(err)
return false, nil
}
allPages, err := servers.List(conn, servers.ListOpts{}).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allServers, err := servers.ExtractServers(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
serverObjects := []ObjectWithTags{}
for _, server := range allServers {
serverObjects = append(
serverObjects, ObjectWithTags{
ID: server.ID,
Tags: server.Metadata})
}
filteredServers := filterObjects(serverObjects, filter)
numberToDelete := len(filteredServers)
numberDeleted := 0
for _, server := range filteredServers {
logger.Debugf("Deleting Server %q", server.ID)
err = servers.Delete(conn, server.ID).ExtractErr()
if err != nil {
// Ignore the error if the server cannot be found and return with an appropriate message if it's another type of error
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// Just log the error and move on to the next server
logger.Errorf("Deleting server %q failed: %v", server.ID, err)
continue
}
logger.Debugf("Cannot find server %q. It's probably already been deleted.", server.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteServerGroups(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack server groups")
defer logger.Debugf("Exiting deleting openstack server groups")
// We need to delete all server groups that have names with the cluster
// ID as a prefix
var clusterID string
for k, v := range filter {
if strings.ToLower(k) == "openshiftclusterid" {
clusterID = v
break
}
}
conn, err := clientconfig.NewServiceClient("compute", opts)
if err != nil {
logger.Error(err)
return false, nil
}
allPages, err := servergroups.List(conn, nil).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allServerGroups, err := servergroups.ExtractServerGroups(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
filteredGroups := make([]servergroups.ServerGroup, 0, len(allServerGroups))
for _, serverGroup := range allServerGroups {
if strings.HasPrefix(serverGroup.Name, clusterID) {
filteredGroups = append(filteredGroups, serverGroup)
}
}
numberToDelete := len(filteredGroups)
numberDeleted := 0
for _, serverGroup := range filteredGroups {
logger.Debugf("Deleting Server Group %q", serverGroup.ID)
if err = servergroups.Delete(conn, serverGroup.ID).ExtractErr(); err != nil {
// Ignore the error if the server cannot be found and
// return with an appropriate message if it's another
// type of error
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// Just log the error and move on to the next server group
logger.Errorf("Deleting server group %q failed: %v", serverGroup.ID, err)
continue
}
logger.Debugf("Cannot find server group %q. It's probably already been deleted.", serverGroup.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deletePortsByNetwork(opts *clientconfig.ClientOpts, networkID string, logger logrus.FieldLogger) (bool, error) {
listOpts := ports.ListOpts{
NetworkID: networkID,
}
result, err := deletePorts(opts, listOpts, logger)
if err != nil {
logger.Error(err)
return false, nil
}
return result, err
}
func deletePortsByFilter(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
tags := filterTags(filter)
listOpts := ports.ListOpts{
TagsAny: strings.Join(tags, ","),
}
result, err := deletePorts(opts, listOpts, logger)
if err != nil {
logger.Error(err)
return false, nil
}
return result, err
}
func getFIPsByPort(conn *gophercloud.ServiceClient, logger logrus.FieldLogger) (map[string]floatingips.FloatingIP, error) {
// Prefetch list of FIPs to save list calls for each port
fipByPort := make(map[string]floatingips.FloatingIP)
allPages, err := floatingips.List(conn, floatingips.ListOpts{}).AllPages()
if err != nil {
logger.Error(err)
return fipByPort, nil
}
allFIPs, err := floatingips.ExtractFloatingIPs(allPages)
if err != nil {
logger.Error(err)
return fipByPort, nil
}
// Organize FIPs for easy lookup
for _, fip := range allFIPs {
fipByPort[fip.PortID] = fip
}
return fipByPort, err
}
// getSGsByID prefetches a list of SGs and organizes it by ID for easy lookup.
func getSGsByID(conn *gophercloud.ServiceClient, logger logrus.FieldLogger) (map[string]sg.SecGroup, error) {
sgByID := make(map[string]sg.SecGroup)
allPages, err := sg.List(conn, sg.ListOpts{}).AllPages()
if err != nil {
logger.Error(err)
return sgByID, nil
}
allSGs, err := sg.ExtractGroups(allPages)
if err != nil {
logger.Error(err)
return sgByID, nil
}
// Organize SGs for easy lookup
for _, group := range allSGs {
sgByID[group.ID] = group
}
return sgByID, err
}
func deletePorts(opts *clientconfig.ClientOpts, listOpts ports.ListOpts, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack ports")
defer logger.Debugf("Exiting deleting openstack ports")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Error(err)
return false, nil
}
allPages, err := ports.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allPorts, err := ports.ExtractPorts(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allPorts)
numberDeleted := 0
fipByPort, err := getFIPsByPort(conn, logger)
if err != nil {
logger.Error(err)
return false, nil
}
sgByID, err := getSGsByID(conn, logger)
if err != nil {
logger.Error(err)
return false, nil
}
cloudProviderSGNameRegexp := regexp.MustCompile(cloudProviderSGNamePattern)
deletePortsWorker := func(portsChannel <-chan ports.Port, deletedChannel chan<- int) {
localDeleted := 0
for port := range portsChannel {
// If a user provisioned floating ip was used, it needs to be dissociated.
// Any floating Ip's associated with ports that are going to be deleted will be dissociated.
if fip, ok := fipByPort[port.ID]; ok {
logger.Debugf("Dissociating Floating IP %q", fip.ID)
_, err := floatingips.Update(conn, fip.ID, floatingips.UpdateOpts{}).Extract()
if err != nil {
// Ignore the error if the floating ip cannot be found and return with an appropriate message if it's another type of error
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// Just log the error and move on to the next port
logger.Errorf("While deleting port %q, the update of the floating IP %q failed with error: %v", port.ID, fip.ID, err)
continue
}
logger.Debugf("Cannot find floating ip %q. It's probably already been deleted.", fip.ID)
}
}
// If there is a security group created by cloud-provider-openstack we should find it and delete it.
// We'll look through the ones on each of the ports and attempt to remove it from the port and delete it.
// Most of the time it's a conflict, but last port should be guaranteed to allow deletion.
// TODO(dulek): Currently this is the only way to do it and if delete fails there's no way to get back to
// that SG. This is bad and we should make groups created by CPO tagged by cluster ID ASAP.
assignedSGs := port.SecurityGroups
ports.Update(conn, port.ID, ports.UpdateOpts{
SecurityGroups: &[]string{}, // We can just detach all, we're deleting this port anyway.
})
for _, groupID := range assignedSGs {
if group, ok := sgByID[groupID]; ok {
if cloudProviderSGNameRegexp.MatchString(group.Name) {
logger.Debugf("Deleting cloud-provider-openstack SG %q", groupID)
err := sg.Delete(conn, groupID).ExtractErr()
var err404 gophercloud.ErrDefault404
var err409 gophercloud.ErrDefault409
if err == nil || errors.As(err, &err404) {
// If SG is gone let's remove it from the map and it'll save us these calls later on.
delete(sgByID, groupID)
} else if !errors.As(err, &err409) { // Ignore 404 Not Found (clause before) and 409 Conflict
logger.Errorf("Deleting SG %q at port %q failed. SG might get orphaned: %v", groupID, port.ID, err)
}
}
}
}
logger.Debugf("Deleting Port %q", port.ID)
err = ports.Delete(conn, port.ID).ExtractErr()
if err != nil {
// This can fail when port is still in use so return/retry
// Just log the error and move on to the next port
logger.Debugf("Deleting Port %q failed with error: %v", port.ID, err)
// Try to delete associated trunk
deleteAssociatedTrunk(conn, logger, port.ID)
continue
}
localDeleted++
}
deletedChannel <- localDeleted
}
const workersNumber = 10
portsChannel := make(chan ports.Port, workersNumber)
deletedChannel := make(chan int, workersNumber)
// start worker goroutines
for i := 0; i < workersNumber; i++ {
go deletePortsWorker(portsChannel, deletedChannel)
}
// feed worker goroutines with ports
for _, port := range allPorts {
portsChannel <- port
}
close(portsChannel)
// wait for them to finish and accumulate number of ports deleted by each
for i := 0; i < workersNumber; i++ {
numberDeleted += <-deletedChannel
}
return numberDeleted == numberToDelete, nil
}
func getSecurityGroups(conn *gophercloud.ServiceClient, filter Filter) ([]sg.SecGroup, error) {
var emptySecurityGroups []sg.SecGroup
tags := filterTags(filter)
listOpts := sg.ListOpts{
TagsAny: strings.Join(tags, ","),
}
allPages, err := sg.List(conn, listOpts).AllPages()
if err != nil {
return emptySecurityGroups, err
}
allGroups, err := sg.ExtractGroups(allPages)
if err != nil {
return emptySecurityGroups, err
}
return allGroups, nil
}
func deleteSecurityGroups(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack security-groups")
defer logger.Debugf("Exiting deleting openstack security-groups")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Error(err)
return false, nil
}
allGroups, err := getSecurityGroups(conn, filter)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allGroups)
numberDeleted := 0
for _, group := range allGroups {
logger.Debugf("Deleting Security Group: %q", group.ID)
err = sg.Delete(conn, group.ID).ExtractErr()
if err != nil {
// Ignore the error if the security group cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// This can fail when sg is still in use by servers
// Just log the error and move on to the next security group
logger.Debugf("Deleting Security Group %q failed with error: %v", group.ID, err)
continue
}
logger.Debugf("Cannot find security group %q. It's probably already been deleted.", group.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func updateFips(allFIPs []floatingips.FloatingIP, opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) error {
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
return err
}
for _, fip := range allFIPs {
logger.Debugf("Updating FIP %s", fip.ID)
_, err := floatingips.Update(conn, fip.ID, floatingips.UpdateOpts{}).Extract()
if err != nil {
// Ignore the error if the resource cannot be found and return with an appropriate message if it's another type of error
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
logger.Errorf("Updating floating IP %q for Router failed: %v", fip.ID, err)
return err
}
logger.Debugf("Cannot find floating ip %q. It's probably already been deleted.", fip.ID)
}
}
return nil
}
// deletePortFIPs looks up FIPs associated to the port and attempts to delete them
func deletePortFIPs(portID string, opts *clientconfig.ClientOpts, logger logrus.FieldLogger) error {
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
return err
}
fipPages, err := floatingips.List(conn, floatingips.ListOpts{PortID: portID}).AllPages()
if err != nil {
logger.Error(err)
return err
}
fips, err := floatingips.ExtractFloatingIPs(fipPages)
if err != nil {
logger.Error(err)
return err
}
for _, fip := range fips {
logger.Debugf("Deleting FIP %q", fip.ID)
err = floatingips.Delete(conn, fip.ID).ExtractErr()
if err != nil {
// Ignore the error if the FIP cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
logger.Errorf("Deleting FIP %q failed: %v", fip.ID, err)
return err
}
logger.Debugf("Cannot find FIP %q. It's probably already been deleted.", fip.ID)
}
}
return nil
}
func getRouters(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) ([]routers.Router, error) {
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
return nil, err
}
tags := filterTags(filter)
listOpts := routers.ListOpts{
TagsAny: strings.Join(tags, ","),
}
allPages, err := routers.List(conn, listOpts).AllPages()
if err != nil {
return nil, err
}
allRouters, err := routers.ExtractRouters(allPages)
if err != nil {
return nil, err
}
return allRouters, nil
}
func deleteRouters(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack routers")
defer logger.Debugf("Exiting deleting openstack routers")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Error(err)
return false, nil
}
allRouters, err := getRouters(opts, filter, logger)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allRouters)
numberDeleted := 0
for _, router := range allRouters {
fipOpts := floatingips.ListOpts{
RouterID: router.ID,
}
fipPages, err := floatingips.List(conn, fipOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allFIPs, err := floatingips.ExtractFloatingIPs(fipPages)
if err != nil {
logger.Error(err)
return false, nil
}
// If a user provisioned floating ip was used, it needs to be dissociated
// Any floating Ip's associated with routers that are going to be deleted will be dissociated
err = updateFips(allFIPs, opts, filter, logger)
if err != nil {
logger.Error(err)
continue
}
// Clean Gateway interface
updateOpts := routers.UpdateOpts{
GatewayInfo: &routers.GatewayInfo{},
}
_, err = routers.Update(conn, router.ID, updateOpts).Extract()
if err != nil {
logger.Error(err)
}
logger.Debugf("Deleting Router %q", router.ID)
err = routers.Delete(conn, router.ID).ExtractErr()
if err != nil {
// Ignore the error if the router cannot be found and return with an appropriate message if it's another type of error
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// Just log the error and move on to the next router
logger.Errorf("Deleting router %q failed: %v", router.ID, err)
continue
}
logger.Debugf("Cannot find router %q. It's probably already been deleted.", router.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func getRouterInterfaces(conn *gophercloud.ServiceClient, allNetworks []networks.Network, logger logrus.FieldLogger) ([]ports.Port, error) {
var routerPorts []ports.Port
for _, network := range allNetworks {
if len(network.Subnets) == 0 {
continue
}
subnet, err := subnets.Get(conn, network.Subnets[0]).Extract()
if err != nil {
logger.Debug(err)
return routerPorts, nil
}
if subnet.GatewayIP == "" {
continue
}
portListOpts := ports.ListOpts{
FixedIPs: []ports.FixedIPOpts{
{
SubnetID: network.Subnets[0],
},
{
IPAddress: subnet.GatewayIP,
},
},
}
allPagesPort, err := ports.List(conn, portListOpts).AllPages()
if err != nil {
logger.Error(err)
return routerPorts, nil
}
routerPorts, err = ports.ExtractPorts(allPagesPort)
if err != nil {
logger.Error(err)
return routerPorts, nil
}
if len(routerPorts) != 0 {
logger.Debugf("Found Port %q connected to Router", routerPorts[0].ID)
return routerPorts, nil
}
}
return routerPorts, nil
}
func clearRouterInterfaces(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debugf("Removing interfaces from router")
defer logger.Debug("Exiting removal of interfaces from router")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Error(err)
return false, nil
}
tags := filterTags(filter)
networkListOpts := networks.ListOpts{
Tags: strings.Join(tags, ","),
}
allNetworksPages, err := networks.List(conn, networkListOpts).AllPages()
if err != nil {
logger.Debug(err)
return false, nil
}
allNetworks, err := networks.ExtractNetworks(allNetworksPages)
if err != nil {
logger.Debug(err)
return false, nil
}
// Identify router by checking any tagged Network that has a Subnet
// with GatewayIP set
routerPorts, err := getRouterInterfaces(conn, allNetworks, logger)
if err != nil {
logger.Debug(err)
return false, nil
}
if len(routerPorts) == 0 {
return true, nil
}
routerID := routerPorts[0].DeviceID
router, err := routers.Get(conn, routerID).Extract()
if err != nil {
logger.Error(err)
return false, nil
}
removed, err := removeRouterInterfaces(conn, filter, *router, logger)
if err != nil {
logger.Debug(err)
return false, nil
}
return removed, nil
}
func removeRouterInterfaces(client *gophercloud.ServiceClient, filter Filter, router routers.Router, logger logrus.FieldLogger) (bool, error) {
// Get router interface ports
portListOpts := ports.ListOpts{
DeviceID: router.ID,
}
allPagesPort, err := ports.List(client, portListOpts).AllPages()
if err != nil {
logger.Error(err)
return false, fmt.Errorf("failed to get ports list: %w", err)
}
allPorts, err := ports.ExtractPorts(allPagesPort)
if err != nil {
logger.Error(err)
return false, fmt.Errorf("failed to extract ports list: %w", err)
}
tags := filterTags(filter)
SubnetlistOpts := subnets.ListOpts{
TagsAny: strings.Join(tags, ","),
}
allSubnetsPage, err := subnets.List(client, SubnetlistOpts).AllPages()
if err != nil {
logger.Debug(err)
return false, fmt.Errorf("failed to list subnets list: %w", err)
}
allSubnets, err := subnets.ExtractSubnets(allSubnetsPage)
if err != nil {
logger.Debug(err)
return false, fmt.Errorf("failed to extract subnets list: %w", err)
}
clusterTag := "openshiftClusterID=" + filter["openshiftClusterID"]
clusterRouter := isClusterRouter(clusterTag, router.Tags)
numberToDelete := len(allPorts)
numberDeleted := 0
var customInterfaces []ports.Port
// map to keep track of whether interface for subnet was already removed
removedSubnets := make(map[string]bool)
for _, port := range allPorts {
for _, IP := range port.FixedIPs {
// Skip removal if Router was not created by CNO or installer and
// interface is not handled by the Cluster
if !clusterRouter && !isClusterSubnet(allSubnets, IP.SubnetID) {
logger.Debugf("Found custom interface %q on Router %q", port.ID, router.ID)
customInterfaces = append(customInterfaces, port)
continue
}
if !removedSubnets[IP.SubnetID] {
removeOpts := routers.RemoveInterfaceOpts{
SubnetID: IP.SubnetID,
}
logger.Debugf("Removing Subnet %q from Router %q", IP.SubnetID, router.ID)
_, err := routers.RemoveInterface(client, router.ID, removeOpts).Extract()
if err != nil {
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// This can fail when subnet is still in use
logger.Debugf("Removing Subnet %q from Router %q failed: %v", IP.SubnetID, router.ID, err)
return false, nil
}
logger.Debugf("Cannot find subnet %q. It's probably already been removed from router %q.", IP.SubnetID, router.ID)
}
removedSubnets[IP.SubnetID] = true
numberDeleted++
}
}
}
numberToDelete -= len(customInterfaces)
return numberToDelete == numberDeleted, nil
}
func isClusterRouter(clusterTag string, tags []string) bool {
for _, tag := range tags {
if clusterTag == tag {
return true
}
}
return false
}
func getRouterByPort(client *gophercloud.ServiceClient, allPorts []ports.Port) (routers.Router, error) {
empty := routers.Router{}
for _, port := range allPorts {
if port.DeviceID != "" {
page, err := routers.List(client, routers.ListOpts{ID: port.DeviceID}).AllPages()
if err != nil {
return empty, fmt.Errorf("failed to get router list: %w", err)
}
routerList, err := routers.ExtractRouters(page)
if err != nil {
return empty, fmt.Errorf("failed to extract routers list: %w", err)
}
if len(routerList) == 1 {
return routerList[0], nil
}
}
}
return empty, nil
}
func deleteLeftoverLoadBalancers(opts *clientconfig.ClientOpts, logger logrus.FieldLogger, networkID string) error {
conn, err := clientconfig.NewServiceClient("load-balancer", opts)
if err != nil {
// Ignore the error if Octavia is not available for the cloud
var gerr *gophercloud.ErrEndpointNotFound
if errors.As(err, &gerr) {
logger.Debug("Skip load balancer deletion because Octavia endpoint is not found")
return nil
}
logger.Error(err)
return err
}
listOpts := loadbalancers.ListOpts{
VipNetworkID: networkID,
}
allPages, err := loadbalancers.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return err
}
allLoadBalancers, err := loadbalancers.ExtractLoadBalancers(allPages)
if err != nil {
logger.Error(err)
return err
}
deleteOpts := loadbalancers.DeleteOpts{
Cascade: true,
}
deleted := 0
for _, loadbalancer := range allLoadBalancers {
if !strings.HasPrefix(loadbalancer.Description, "Kubernetes external service") {
logger.Debugf("Not deleting LoadBalancer %q with description %q", loadbalancer.ID, loadbalancer.Description)
continue
}
logger.Debugf("Deleting LoadBalancer %q", loadbalancer.ID)
// Cascade delete of an LB won't remove the associated FIP, we have to do it ourselves.
err := deletePortFIPs(loadbalancer.VipPortID, opts, logger)
if err != nil {
// Go to the next LB, but do not delete current one or we'll lose reference to the FIP that failed deletion.
continue
}
err = loadbalancers.Delete(conn, loadbalancer.ID, deleteOpts).ExtractErr()
if err != nil {
// Ignore the error if the load balancer cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// This can fail when the load balancer is still in use so return/retry
// Just log the error and move on to the next LB
logger.Debugf("Deleting load balancer %q failed: %v", loadbalancer.ID, err)
continue
}
logger.Debugf("Cannot find load balancer %q. It's probably already been deleted.", loadbalancer.ID)
}
deleted++
}
if deleted != len(allLoadBalancers) {
return fmt.Errorf("only deleted %d of %d load balancers", deleted, len(allLoadBalancers))
}
return nil
}
func isClusterSubnet(subnets []subnets.Subnet, subnetID string) bool {
for _, subnet := range subnets {
if subnet.ID == subnetID {
return true
}
}
return false
}
func deleteSubnets(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack subnets")
defer logger.Debugf("Exiting deleting openstack subnets")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Error(err)
return false, nil
}
tags := filterTags(filter)
listOpts := subnets.ListOpts{
TagsAny: strings.Join(tags, ","),
}
allPages, err := subnets.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allSubnets, err := subnets.ExtractSubnets(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allSubnets)
numberDeleted := 0
for _, subnet := range allSubnets {
logger.Debugf("Deleting Subnet: %q", subnet.ID)
err = subnets.Delete(conn, subnet.ID).ExtractErr()
if err != nil {
// Ignore the error if the subnet cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// This can fail when subnet is still in use
// Just log the error and move on to the next subnet
logger.Debugf("Deleting Subnet %q failed: %v", subnet.ID, err)
continue
}
logger.Debugf("Cannot find subnet %q. It's probably already been deleted.", subnet.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteNetworks(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack networks")
defer logger.Debugf("Exiting deleting openstack networks")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Error(err)
return false, nil
}
tags := filterTags(filter)
listOpts := networks.ListOpts{
TagsAny: strings.Join(tags, ","),
}
allPages, err := networks.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allNetworks, err := networks.ExtractNetworks(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allNetworks)
numberDeleted := 0
for _, network := range allNetworks {
logger.Debugf("Deleting network: %q", network.ID)
err = networks.Delete(conn, network.ID).ExtractErr()
if err != nil {
// Ignore the error if the network cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// This can fail when network is still in use. Let's log an error and try to fix this.
logger.Debugf("Deleting Network %q failed: %v", network.ID, err)
// First try to delete eventual leftover load balancers
// *This has to be done before attempt to remove ports or we'll delete LB ports!*
err := deleteLeftoverLoadBalancers(opts, logger, network.ID)
if err != nil {
logger.Error(err)
// Do not attempt to delete ports on LB removal problem or we'll lose FIP associations!
continue
}
// Only then try to remove all the ports it may still contain (untagged as well).
// *We cannot delete ports before LBs because we'll lose FIP associations!*
_, err = deletePortsByNetwork(opts, network.ID, logger)
if err != nil {
logger.Error(err)
}
continue
}
logger.Debugf("Cannot find network %q. It's probably already been deleted.", network.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteContainers(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack containers")
defer logger.Debugf("Exiting deleting openstack containers")
conn, err := clientconfig.NewServiceClient("object-store", opts)
if err != nil {
// Ignore the error if Swift is not available for the cloud
var gerr *gophercloud.ErrEndpointNotFound
if errors.As(err, &gerr) {
logger.Debug("Skip container deletion because Swift endpoint is not found")
return true, nil
}
logger.Error(err)
return false, nil
}
listOpts := containers.ListOpts{Full: false}
allPages, err := containers.List(conn, listOpts).AllPages()
if err != nil {
// Ignore the error if the user doesn't have the swiftoperator role.
// Depending on the configuration Swift returns different error codes:
// 403 with Keystone and 401 with internal Swauth.
// It means we have to catch them both.
// More information about Swith auth: https://docs.openstack.org/swift/latest/overview_auth.html
var gerr403 gophercloud.ErrDefault403
if errors.As(err, &gerr403) {
logger.Debug("Skip container deletion because the user doesn't have the `swiftoperator` role")
return true, nil
}
var gerr401 gophercloud.ErrDefault401
if errors.As(err, &gerr401) {
logger.Debug("Skip container deletion because the user doesn't have the `swiftoperator` role")
return true, nil
}
logger.Error(err)
return false, nil
}
allContainers, err := containers.ExtractNames(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
for _, container := range allContainers {
metadata, err := containers.Get(conn, container, nil).ExtractMetadata()
if err != nil {
// Some containers that we fetched previously can already be deleted in
// runtime. We should ignore these cases and continue to iterate through
// the remaining containers.
var gerr gophercloud.ErrDefault404
if errors.As(err, &gerr) {
continue
}
logger.Error(err)
return false, nil
}
for key, val := range filter {
// Swift mangles the case so openshiftClusterID becomes
// Openshiftclusterid in the X-Container-Meta- HEAD output
titlekey := strings.Title(strings.ToLower(key))
if metadata[titlekey] == val {
queue := newSemaphore(3)
errCh := make(chan error)
err := objects.List(conn, container, nil).EachPage(func(page pagination.Page) (bool, error) {
objectsOnPage, err := objects.ExtractNames(page)
if err != nil {
return false, err
}
queue.Add(func() {
for len(objectsOnPage) > 0 {
logger.Debugf("Initiating bulk deletion of %d objects in container %q", len(objectsOnPage), container)
resp, err := objects.BulkDelete(conn, container, objectsOnPage).Extract()
if err != nil {
errCh <- err
return
}
if len(resp.Errors) > 0 {
// Convert resp.Errors to golang errors.
// Each error is represented by a list of 2 strings, where the first one
// is the object name, and the second one contains an error message.
for _, objectError := range resp.Errors {
errCh <- fmt.Errorf("cannot delete object %q: %s", objectError[0], objectError[1])
}
logger.Debugf("Terminating object deletion routine with error. Deleted %d objects out of %d.", resp.NumberDeleted, len(objectsOnPage))
}
// Some object-storage instances may be set to have a limit to the LIST operation
// that is higher to the limit to the BULK DELETE operation. On those clouds, objects
// in the BULK DELETE call beyond the limit are silently ignored. In this loop, after
// checking that no errors were encountered, we reduce the BULK DELETE list by the
// number of processed objects, and send it back to the server if it's not empty.
objectsOnPage = objectsOnPage[resp.NumberDeleted+resp.NumberNotFound:]
}
logger.Debugf("Terminating object deletion routine.")
})
return true, nil
})
if err != nil {
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
logger.Errorf("Bulk deletion of container %q objects failed: %v", container, err)
return false, nil
}
}
var errs []error
go func() {
for err := range errCh {
errs = append(errs, err)
}
}()
queue.Wait()
close(errCh)
if len(errs) > 0 {
return false, fmt.Errorf("errors occurred during bulk deletion of the objects of container %q: %w", container, k8serrors.NewAggregate(errs))
}
logger.Debugf("Deleting container %q", container)
_, err = containers.Delete(conn, container).Extract()
if err != nil {
// Ignore the error if the container cannot be found and return with an appropriate message if it's another type of error
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
logger.Errorf("Deleting container %q failed: %v", container, err)
return false, nil
}
logger.Debugf("Cannot find container %q. It's probably already been deleted.", container)
}
// If a metadata key matched, we're done so break from the loop
break
}
}
}
return true, nil
}
func deleteTrunks(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack trunks")
defer logger.Debugf("Exiting deleting openstack trunks")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Error(err)
return false, nil
}
tags := filterTags(filter)
listOpts := trunks.ListOpts{
TagsAny: strings.Join(tags, ","),
}
allPages, err := trunks.List(conn, listOpts).AllPages()
if err != nil {
var gerr gophercloud.ErrDefault404
if errors.As(err, &gerr) {
logger.Debug("Skip trunk deletion because the cloud doesn't support trunk ports")
return true, nil
}
logger.Error(err)
return false, nil
}
allTrunks, err := trunks.ExtractTrunks(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allTrunks)
numberDeleted := 0
for _, trunk := range allTrunks {
logger.Debugf("Deleting Trunk %q", trunk.ID)
err = trunks.Delete(conn, trunk.ID).ExtractErr()
if err != nil {
// Ignore the error if the trunk cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// This can fail when the trunk is still in use so return/retry
// Just log the error and move on to the next trunk
logger.Debugf("Deleting Trunk %q failed: %v", trunk.ID, err)
continue
}
logger.Debugf("Cannot find trunk %q. It's probably already been deleted.", trunk.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteAssociatedTrunk(conn *gophercloud.ServiceClient, logger logrus.FieldLogger, portID string) {
logger.Debug("Deleting associated trunk")
defer logger.Debugf("Exiting deleting associated trunk")
listOpts := trunks.ListOpts{
PortID: portID,
}
allPages, err := trunks.List(conn, listOpts).AllPages()
if err != nil {
var gerr gophercloud.ErrDefault404
if errors.As(err, &gerr) {
logger.Debug("Skip trunk deletion because the cloud doesn't support trunk ports")
return
}
logger.Error(err)
return
}
allTrunks, err := trunks.ExtractTrunks(allPages)
if err != nil {
logger.Error(err)
return
}
for _, trunk := range allTrunks {
logger.Debugf("Deleting Trunk %q", trunk.ID)
err = trunks.Delete(conn, trunk.ID).ExtractErr()
if err != nil {
// Ignore the error if the trunk cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// This can fail when the trunk is still in use so return/retry
// Just log the error and move on to the next trunk
logger.Debugf("Deleting Trunk %q failed: %v", trunk.ID, err)
continue
}
logger.Debugf("Cannot find trunk %q. It's probably already been deleted.", trunk.ID)
}
}
return
}
func deleteLoadBalancers(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack load balancers")
defer logger.Debugf("Exiting deleting openstack load balancers")
conn, err := clientconfig.NewServiceClient("load-balancer", opts)
if err != nil {
// Ignore the error if Octavia is not available for the cloud
var gerr *gophercloud.ErrEndpointNotFound
if errors.As(err, &gerr) {
logger.Debug("Skip load balancer deletion because Octavia endpoint is not found")
return true, nil
}
logger.Error(err)
return false, nil
}
newallPages, err := apiversions.List(conn).AllPages()
if err != nil {
logger.Errorf("Unable to list api versions: %v", err)
return false, nil
}
allAPIVersions, err := apiversions.ExtractAPIVersions(newallPages)
if err != nil {
logger.Errorf("Unable to extract api versions: %v", err)
return false, nil
}
var octaviaTagSupport bool
octaviaTagSupport = false
for _, apiVersion := range allAPIVersions {
if apiVersion.ID >= minOctaviaVersionWithTagSupport {
octaviaTagSupport = true
}
}
tags := filterTags(filter)
var allLoadBalancers []loadbalancers.LoadBalancer
if octaviaTagSupport {
listOpts := loadbalancers.ListOpts{
TagsAny: tags,
}
allPages, err := loadbalancers.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allLoadBalancers, err = loadbalancers.ExtractLoadBalancers(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
}
listOpts := loadbalancers.ListOpts{
Description: strings.Join(tags, ","),
}
allPages, err := loadbalancers.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allLoadBalancersWithTaggedDescription, err := loadbalancers.ExtractLoadBalancers(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
allLoadBalancers = append(allLoadBalancers, allLoadBalancersWithTaggedDescription...)
deleteOpts := loadbalancers.DeleteOpts{
Cascade: true,
}
numberToDelete := len(allLoadBalancers)
numberDeleted := 0
for _, loadbalancer := range allLoadBalancers {
logger.Debugf("Deleting LoadBalancer %q", loadbalancer.ID)
err = loadbalancers.Delete(conn, loadbalancer.ID, deleteOpts).ExtractErr()
if err != nil {
// Ignore the error if the load balancer cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// This can fail when the load balancer is still in use so return/retry
// Just log the error and move on to the next port
logger.Debugf("Deleting load balancer %q failed: %v", loadbalancer.ID, err)
continue
}
logger.Debugf("Cannot find load balancer %q. It's probably already been deleted.", loadbalancer.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteSubnetPools(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack subnet-pools")
defer logger.Debugf("Exiting deleting openstack subnet-pools")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Error(err)
return false, nil
}
tags := filterTags(filter)
listOpts := subnetpools.ListOpts{
TagsAny: strings.Join(tags, ","),
}
allPages, err := subnetpools.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allSubnetPools, err := subnetpools.ExtractSubnetPools(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allSubnetPools)
numberDeleted := 0
for _, subnetPool := range allSubnetPools {
logger.Debugf("Deleting Subnet Pool %q", subnetPool.ID)
err = subnetpools.Delete(conn, subnetPool.ID).ExtractErr()
if err != nil {
// Ignore the error if the subnet pool cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// Just log the error and move on to the next subnet pool
logger.Debugf("Deleting subnet pool %q failed: %v", subnetPool.ID, err)
continue
}
logger.Debugf("Cannot find subnet pool %q. It's probably already been deleted.", subnetPool.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteVolumes(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting OpenStack volumes")
defer logger.Debugf("Exiting deleting OpenStack volumes")
var clusterID string
for k, v := range filter {
if strings.ToLower(k) == "openshiftclusterid" {
clusterID = v
break
}
}
conn, err := clientconfig.NewServiceClient("volume", opts)
if err != nil {
logger.Error(err)
return false, nil
}
listOpts := volumes.ListOpts{}
allPages, err := volumes.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allVolumes, err := volumes.ExtractVolumes(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
volumeIDs := []string{}
for _, volume := range allVolumes {
// First, we need to delete all volumes that have names with the cluster ID as a prefix.
// They are created by the in-tree Cinder provisioner.
if strings.HasPrefix(volume.Name, clusterID) {
volumeIDs = append(volumeIDs, volume.ID)
}
// Second, we need to delete volumes created by the CSI driver. They contain their cluster ID
// in the metadata.
if val, ok := volume.Metadata[cinderCSIClusterIDKey]; ok && val == clusterID {
volumeIDs = append(volumeIDs, volume.ID)
}
}
deleteOpts := volumes.DeleteOpts{
Cascade: false,
}
numberToDelete := len(volumeIDs)
numberDeleted := 0
for _, volumeID := range volumeIDs {
logger.Debugf("Deleting volume %q", volumeID)
err = volumes.Delete(conn, volumeID, deleteOpts).ExtractErr()
if err != nil {
// Ignore the error if the volume cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// Just log the error and move on to the next volume
logger.Debugf("Deleting volume %q failed: %v", volumeID, err)
continue
}
logger.Debugf("Cannot find volume %q. It's probably already been deleted.", volumeID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteVolumeSnapshots(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting OpenStack volume snapshots")
defer logger.Debugf("Exiting deleting OpenStack volume snapshots")
var clusterID string
for k, v := range filter {
if strings.ToLower(k) == "openshiftclusterid" {
clusterID = v
break
}
}
conn, err := clientconfig.NewServiceClient("volume", opts)
if err != nil {
logger.Error(err)
return false, nil
}
listOpts := snapshots.ListOpts{}
allPages, err := snapshots.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allSnapshots, err := snapshots.ExtractSnapshots(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allSnapshots)
numberDeleted := 0
for _, snapshot := range allSnapshots {
// Delete only those snapshots that contain cluster ID in the metadata
if val, ok := snapshot.Metadata[cinderCSIClusterIDKey]; ok && val == clusterID {
logger.Debugf("Deleting volume snapshot %q", snapshot.ID)
err = snapshots.Delete(conn, snapshot.ID).ExtractErr()
if err != nil {
// Ignore the error if the server cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// Just log the error and move on to the next volume snapshot
logger.Debugf("Deleting volume snapshot %q failed: %v", snapshot.ID, err)
continue
}
logger.Debugf("Cannot find volume snapshot %q. It's probably already been deleted.", snapshot.ID)
}
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteShares(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting OpenStack shares")
defer logger.Debugf("Exiting deleting OpenStack shares")
var clusterID string
for k, v := range filter {
if strings.ToLower(k) == "openshiftclusterid" {
clusterID = v
break
}
}
conn, err := clientconfig.NewServiceClient("sharev2", opts)
if err != nil {
// Ignore the error if Manila is not available in the cloud
var gerr *gophercloud.ErrEndpointNotFound
if errors.As(err, &gerr) {
logger.Debug("Skip share deletion because Manila endpoint is not found")
return true, nil
}
logger.Error(err)
return false, nil
}
listOpts := shares.ListOpts{
Metadata: map[string]string{manilaCSIClusterIDKey: clusterID},
}
allPages, err := shares.ListDetail(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allShares, err := shares.ExtractShares(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allShares)
numberDeleted := 0
for _, share := range allShares {
deleted, err := deleteShareSnapshots(conn, share.ID, logger)
if err != nil {
return false, err
}
if !deleted {
return false, nil
}
logger.Debugf("Deleting share %q", share.ID)
err = shares.Delete(conn, share.ID).ExtractErr()
if err != nil {
// Ignore the error if the share cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// Just log the error and move on to the next share
logger.Debugf("Deleting share %q failed: %v", share.ID, err)
continue
}
logger.Debugf("Cannot find share %q. It's probably already been deleted.", share.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteShareSnapshots(conn *gophercloud.ServiceClient, shareID string, logger logrus.FieldLogger) (bool, error) {
logger.Debugf("Deleting OpenStack snapshots for share %v", shareID)
defer logger.Debugf("Exiting deleting OpenStack snapshots for share %v", shareID)
listOpts := sharesnapshots.ListOpts{
ShareID: shareID,
}
allPages, err := sharesnapshots.ListDetail(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allSnapshots, err := sharesnapshots.ExtractSnapshots(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allSnapshots)
numberDeleted := 0
for _, snapshot := range allSnapshots {
logger.Debugf("Deleting share snapshot %q", snapshot.ID)
err = sharesnapshots.Delete(conn, snapshot.ID).ExtractErr()
if err != nil {
// Ignore the error if the share snapshot cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// Just log the error and move on to the next share snapshot
logger.Debugf("Deleting share snapshot %q failed: %v", snapshot.ID, err)
continue
}
logger.Debugf("Cannot find share snapshot %q. It's probably already been deleted.", snapshot.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteFloatingIPs(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack floating ips")
defer logger.Debugf("Exiting deleting openstack floating ips")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Error(err)
return false, nil
}
tags := filterTags(filter)
listOpts := floatingips.ListOpts{
TagsAny: strings.Join(tags, ","),
}
allPages, err := floatingips.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allFloatingIPs, err := floatingips.ExtractFloatingIPs(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allFloatingIPs)
numberDeleted := 0
for _, floatingIP := range allFloatingIPs {
logger.Debugf("Deleting Floating IP %q", floatingIP.ID)
err = floatingips.Delete(conn, floatingIP.ID).ExtractErr()
if err != nil {
// Ignore the error if the floating ip cannot be found
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
// Just log the error and move on to the next floating IP
logger.Debugf("Deleting floating ip %q failed: %v", floatingIP.ID, err)
continue
}
logger.Debugf("Cannot find floating ip %q. It's probably already been deleted.", floatingIP.ID)
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func deleteImages(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Deleting openstack base image")
defer logger.Debugf("Exiting deleting openstack base image")
conn, err := clientconfig.NewServiceClient("image", opts)
if err != nil {
logger.Error(err)
return false, nil
}
listOpts := images.ListOpts{
Tags: filterTags(filter),
}
allPages, err := images.List(conn, listOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allImages, err := images.ExtractImages(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToDelete := len(allImages)
numberDeleted := 0
for _, image := range allImages {
logger.Debugf("Deleting image: %+v", image.ID)
err := images.Delete(conn, image.ID).ExtractErr()
if err != nil {
// This can fail if the image is still in use by other VMs
// Just log the error and move on to the next image
logger.Debugf("Deleting Image failed: %v", err)
continue
}
numberDeleted++
}
return numberDeleted == numberToDelete, nil
}
func untagRunner(opts *clientconfig.ClientOpts, infraID string, logger logrus.FieldLogger) error {
backoffSettings := wait.Backoff{
Duration: time.Second * 10,
Steps: 25,
}
err := wait.ExponentialBackoff(backoffSettings, func() (bool, error) {
return untagPrimaryNetwork(opts, infraID, logger)
})
if err != nil {
if err == wait.ErrWaitTimeout {
return err
}
return fmt.Errorf("unrecoverable error: %w", err)
}
return nil
}
func deleteRouterRunner(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) error {
backoffSettings := wait.Backoff{
Duration: time.Second * 15,
Factor: 1.3,
Steps: 25,
}
err := wait.ExponentialBackoff(backoffSettings, func() (bool, error) {
return deleteRouters(opts, filter, logger)
})
if err != nil {
if err == wait.ErrWaitTimeout {
return err
}
return fmt.Errorf("unrecoverable error: %w", err)
}
return nil
}
// untagNetwork removes the tag from the primary cluster network based on unfra id
func untagPrimaryNetwork(opts *clientconfig.ClientOpts, infraID string, logger logrus.FieldLogger) (bool, error) {
networkTag := infraID + "-primaryClusterNetwork"
logger.Debugf("Removing tag %v from openstack networks", networkTag)
defer logger.Debug("Exiting untagging openstack networks")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Debug(err)
return false, nil
}
listOpts := networks.ListOpts{
Tags: networkTag,
}
allPages, err := networks.List(conn, listOpts).AllPages()
if err != nil {
logger.Debug(err)
return false, nil
}
allNetworks, err := networks.ExtractNetworks(allPages)
if err != nil {
logger.Debug(err)
return false, nil
}
if len(allNetworks) > 1 {
return false, fmt.Errorf("more than one network with tag %s", networkTag)
}
if len(allNetworks) == 0 {
// The network has already been deleted.
return true, nil
}
err = attributestags.Delete(conn, "networks", allNetworks[0].ID, networkTag).ExtractErr()
if err != nil {
return false, nil
}
return true, nil
}
// validateCloud checks that the target cloud fulfills the minimum requirements
// for destroy to function.
func validateCloud(opts *clientconfig.ClientOpts, logger logrus.FieldLogger) error {
logger.Debug("Validating the cloud")
// A lack of support for network tagging can lead the Installer to
// delete unmanaged resources.
//
// See https://bugzilla.redhat.com/show_bug.cgi?id=2013877
logger.Debug("Validating network extensions")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
return fmt.Errorf("failed to build the network client: %w", err)
}
availableExtensions, err := networkextensions.Get(conn)
if err != nil {
return fmt.Errorf("failed to fetch network extensions: %w", err)
}
return networkextensions.Validate(availableExtensions)
}
// cleanClusterSgs removes the installer security groups from the user provided Port.
func cleanClusterSgs(providedPortSGs []string, clusterSGs []sg.SecGroup) []string {
var sgs []string
for _, providedPortSG := range providedPortSGs {
if !isClusterSG(providedPortSG, clusterSGs) {
sgs = append(sgs, providedPortSG)
}
}
return sgs
}
func isClusterSG(providedPortSG string, clusterSGs []sg.SecGroup) bool {
for _, clusterSG := range clusterSGs {
if providedPortSG == clusterSG.ID {
return true
}
}
return false
}
func cleanVIPsPorts(opts *clientconfig.ClientOpts, filter Filter, logger logrus.FieldLogger) (bool, error) {
logger.Debug("Cleaning provided Ports for API and Ingress VIPs")
defer logger.Debugf("Exiting clean of provided Ports for API and Ingress VIPs")
conn, err := clientconfig.NewServiceClient("network", opts)
if err != nil {
logger.Error(err)
return false, nil
}
tag := filter["openshiftClusterID"] + openstackdefaults.DualStackVIPsPortTag
PortlistOpts := ports.ListOpts{
TagsAny: tag,
}
allPages, err := ports.List(conn, PortlistOpts).AllPages()
if err != nil {
logger.Error(err)
return false, nil
}
allPorts, err := ports.ExtractPorts(allPages)
if err != nil {
logger.Error(err)
return false, nil
}
numberToClean := len(allPorts)
numberCleaned := 0
// Updating user provided API and Ingress Ports
if len(allPorts) > 0 {
clusterSGs, err := getSecurityGroups(conn, filter)
if err != nil {
logger.Error(err)
return false, nil
}
fipByPort, err := getFIPsByPort(conn, logger)
if err != nil {
logger.Error(err)
return false, nil
}
for _, port := range allPorts {
logger.Debugf("Updating security groups for Port: %q", port.ID)
sgs := cleanClusterSgs(port.SecurityGroups, clusterSGs)
_, err := ports.Update(conn, port.ID, ports.UpdateOpts{SecurityGroups: &sgs}).Extract()
if err != nil {
return false, nil
}
if fip, ok := fipByPort[port.ID]; ok {
logger.Debugf("Dissociating Floating IP %q", fip.ID)
_, err := floatingips.Update(conn, fip.ID, floatingips.UpdateOpts{}).Extract()
if err != nil {
// Ignore the error if the floating ip cannot be found and return with an appropriate message if it's another type of error
var gerr gophercloud.ErrDefault404
if !errors.As(err, &gerr) {
return false, nil
}
logger.Debugf("Cannot find floating ip %q. It's probably already been deleted.", fip.ID)
}
}
logger.Debugf("Deleting tag for Port: %q", port.ID)
err = attributestags.Delete(conn, "ports", port.ID, tag).ExtractErr()
if err != nil {
return false, nil
}
numberCleaned++
}
}
return numberCleaned == numberToClean, nil
}
|
package controllers
import (
"log"
"github.com/messagedb/messagedb/meta"
"github.com/messagedb/messagedb/services/httpd/helpers"
"github.com/gin-gonic/gin"
)
// DeviceController handles RESTful API requests for an Device resources
type DevicesController struct {
Engine *gin.Engine
MetaStore interface {
Database(name string) (*meta.DatabaseInfo, error)
Authenticate(username, password string) (ui *meta.UserInfo, err error)
Users() ([]meta.UserInfo, error)
// Devices() ([]meta.DeviceInfo, error)
}
Logger *log.Logger
logginEnabled bool // Log every HTTP access
WriteTrace bool // Detail logging of controller handler
}
func NewDevicesController(engine *gin.Engine, logginEnabled, writeTrace bool) *DevicesController {
c := &DevicesController{
Engine: engine,
logginEnabled: logginEnabled,
WriteTrace: writeTrace,
}
c.registerRoutes()
return c
}
func (c *DevicesController) registerRoutes() error {
router := c.Engine
router.GET("/devices", c.ListDevices)
router.POST("/devices", c.AddDevice)
devicesRouter := router.Group("/")
devicesRouter.Use(DeviceFilter())
{
devicesRouter.GET("/devices/:id", c.GetDevice)
devicesRouter.PATCH("/devices/:id", c.EditDevice)
devicesRouter.DELETE("/devices/:id", c.DeleteDevice)
}
return nil
}
// ListDevices returns the list of client devices associated with the authenticated user
//
// GET /devices
//
func (c *DevicesController) ListDevices(ctx *gin.Context) {
helpers.JSONResponseNotImplemented(ctx)
}
// AddDevice registers a new client device to the authenticated user
//
// POST /devices
//
func (c *DevicesController) AddDevice(ctx *gin.Context) {
helpers.JSONResponseNotImplemented(ctx)
}
// GetDevice returns a client device
//
// GET /devices/:id
//
func (c *DevicesController) GetDevice(ctx *gin.Context) {
_ = ctx.MustGet("device")
helpers.JSONResponseNotImplemented(ctx)
}
// EditDevice modifies the client device
//
// PATCH /devices/:id
//
func (c *DevicesController) EditDevice(ctx *gin.Context) {
_ = ctx.MustGet("device")
helpers.JSONResponseNotImplemented(ctx)
}
// DeleteDevice removes a client device from the authenticated users' account
//
// DELETE /devices/:id
//
func (c *DevicesController) DeleteDevice(ctx *gin.Context) {
_ = ctx.MustGet("device")
helpers.JSONResponseNotImplemented(ctx)
}
|
package quic
import (
"gx/ipfs/QmU44KWVkSHno7sNDTeUcL4FBgxgoidkFuTUyTXWJPXXFJ/quic-go/internal/protocol"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Crypto Stream", func() {
var (
str *cryptoStreamImpl
mockSender *MockStreamSender
)
BeforeEach(func() {
mockSender = NewMockStreamSender(mockCtrl)
str = newCryptoStream(mockSender, nil, protocol.VersionWhatever).(*cryptoStreamImpl)
})
It("sets the read offset", func() {
str.setReadOffset(0x42)
Expect(str.receiveStream.readOffset).To(Equal(protocol.ByteCount(0x42)))
Expect(str.receiveStream.frameQueue.readPos).To(Equal(protocol.ByteCount(0x42)))
})
})
|
/**
* Copyright (c) 2018 ZTE Corporation.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and the Apache License 2.0 which both accompany this distribution,
* and are available at http://www.eclipse.org/legal/epl-v10.html
* and http://www.apache.org/licenses/LICENSE-2.0
*
* Contributors:
* ZTE - initial Project
*/
package main
import (
"msb2pilot/consul"
"msb2pilot/log"
"msb2pilot/models"
"msb2pilot/pilot"
_ "msb2pilot/routers"
"time"
"github.com/astaxie/beego"
)
func main() {
log.Log.Informational("**************** init msb2pilot ************************")
// start sync msb data
go syncConsulData()
beego.Run()
}
func syncConsulData() {
stop := make(chan struct{})
monitor := consul.NewConsulMonitor(nil, 20*time.Second, syncMsbData)
monitor.Start(stop)
}
func syncMsbData(newServices []*models.MsbService) {
stop := make(chan struct{})
monitor := consul.NewConsulMonitor(nil, 20*time.Second, pilot.SyncMsbData)
monitor.Start(stop)
}
|
package admin
import (
"context"
"tpay_backend/adminapi/internal/common"
"tpay_backend/model"
"tpay_backend/adminapi/internal/svc"
"tpay_backend/adminapi/internal/types"
"github.com/tal-tech/go-zero/core/logx"
)
type EnableAdminLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewEnableAdminLogic(ctx context.Context, svcCtx *svc.ServiceContext) EnableAdminLogic {
return EnableAdminLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *EnableAdminLogic) EnableAdmin(req types.EnableAdminRequest) error {
exist, err := model.NewAdminModel(l.svcCtx.DbEngine).CheckById(req.AdminId)
if err != nil {
l.Logger.Errorf("查询管理员[%v]是否存在失败, err=%v", req.AdminId, err)
return common.NewCodeError(common.SysDBUpdate)
}
if !exist {
l.Logger.Errorf("管理员[%v]不存在")
return common.NewCodeError(common.UserNotExist)
}
switch req.Enable {
case model.AdminEnableStatus:
err = model.NewAdminModel(l.svcCtx.DbEngine).Enable(req.AdminId)
if err != nil {
l.Logger.Errorf("修改管理员[%v]账号开启状态失败, err=%v", req.AdminId, err)
return common.NewCodeError(common.SysDBUpdate)
}
case model.AdminDisableStatus:
err = model.NewAdminModel(l.svcCtx.DbEngine).Disable(req.AdminId)
if err != nil {
l.Logger.Errorf("修改管理员[%v]账号开启状态失败, err=%v", req.AdminId, err)
return common.NewCodeError(common.SysDBUpdate)
}
//清除管理员的登录token
if errDel := l.svcCtx.RedisSession.CleanOtherLogined(req.AdminId); errDel != nil {
l.Errorf("删除管理员[%v]的登录token失败", req.AdminId)
return common.NewCodeError(common.SystemInternalErr)
}
default:
l.Logger.Errorf("无效参数, req.enable=%v", req.Enable)
return common.NewCodeError(common.InvalidParam)
}
return nil
}
|
// +build linux
package nio
import (
"fmt"
"syscall"
)
func newPoller() poller {
return &epoll{}
}
// https://medium.com/@copyconstruct/the-method-to-epolls-madness-d9d2d6378642
type epoll struct {
efd int // epoll fd
wfd int // wakeup fd
events []syscall.EpollEvent
}
func epoll_create() (int, error) {
fd, err := syscall.EpollCreate1(0)
if err == nil {
return fd, nil
}
return syscall.EpollCreate(1024)
}
func (p *epoll) Open() error {
fd, err := epoll_create()
if err != nil {
return err
}
r0, _, e0 := syscall.Syscall(syscall.SYS_EVENTFD2, 0, 0, 0)
if e0 != 0 {
syscall.Close(fd)
return fmt.Errorf("create eventfd fail")
}
syscall.CloseOnExec(fd)
p.events = make([]syscall.EpollEvent, maxEventNum)
p.efd = fd
p.wfd = int(r0)
return nil
}
func (p *epoll) Close() error {
if err := syscall.Close(p.wfd); err != nil {
return err
}
return syscall.Close(p.efd)
}
func (p *epoll) Wakeup() error {
_, err := syscall.Write(p.wfd, []byte{0, 0, 0, 0, 0, 0, 0, 1})
return err
}
func (p *epoll) Wait(s *Selector, cb SelectCB, msec int) error {
for {
n, err := syscall.EpollWait(p.efd, p.events, msec)
if err != nil {
if isTemporaryError(err) {
continue
}
return err
}
for i := 0; i < n; i++ {
ev := &p.events[i]
fd := uintptr(ev.Fd)
if fd == uintptr(p.wfd) {
continue
}
sk := s.keys[fd]
if sk == nil {
// close socket?
continue
}
sk.reset()
if ev.Events&(syscall.EPOLLIN|syscall.EPOLLERR|syscall.EPOLLHUP) != 0 {
sk.setReadyIn()
}
if ev.Events&(syscall.EPOLLOUT|syscall.EPOLLERR|syscall.EPOLLHUP) != 0 {
sk.setReadyOut()
}
if cb != nil {
cb(sk)
} else {
s.readyKeys = append(s.readyKeys, sk)
}
}
return nil
}
return nil
}
func (p *epoll) Add(fd uintptr, ops int) error {
ev := &syscall.EpollEvent{Events: toEpollEvents(ops), Fd: int32(fd)}
return syscall.EpollCtl(p.efd, syscall.EPOLL_CTL_ADD, int(fd), ev)
}
func (p *epoll) Delete(fd uintptr, ops int) error {
return syscall.EpollCtl(p.efd, syscall.EPOLL_CTL_DEL, int(fd), nil)
}
func (p *epoll) Modify(fd uintptr, old, ops int) error {
ev := &syscall.EpollEvent{Events: toEpollEvents(ops), Fd: int32(fd)}
return syscall.EpollCtl(p.efd, syscall.EPOLL_CTL_MOD, int(fd), ev)
}
func toEpollEvents(ops int) uint32 {
events := syscall.EPOLLET | syscall.EPOLLPRI
if ops&op_IN != 0 {
events |= syscall.EPOLLIN
}
if ops&op_OUT != 0 {
events |= syscall.EPOLLOUT
}
return uint32(events)
}
|
package main
import (
"flag"
"fmt"
"os"
"mys3/src"
)
func usage() {
fmt.Fprintf(os.Stderr, "usage: mys3 (ls|...) [bucketname] [path]\n")
flag.PrintDefaults()
os.Exit(2)
}
func main() {
a := &mys3.S3Account{}
a.Load(os.Getenv("HOME") + "/.s3cfg")
flag.Usage = usage
flag.Parse()
subcmd := flag.Arg(0)
switch subcmd {
case "get":
mys3.GetObject(*a, flag.Arg(1), flag.Arg(2))
case "put":
mys3.PutObject(*a, flag.Arg(1), flag.Arg(2))
case "info":
if len(flag.Args()) < 2 {
flag.Usage()
}
mys3.ShowPolicy(*a, flag.Arg(1))
mys3.ShowLocation(*a, flag.Arg(1))
case "ls":
if len(flag.Args()) == 1 {
mys3.ListAllMyBuckets(*a)
}else if len(flag.Args()) == 2 {
mys3.ListBucket(*a, flag.Arg(1))
}
case "mp":
mys3.ListMultipartUploads(*a, flag.Arg(1))
default:
flag.Usage()
}
}
|
package utils
import (
"bufio"
"os"
"regexp"
"strconv"
"strings"
)
func ParseGoSolution() []Result {
// List all java source code file
filesPath := make([]string, 0)
entries, err := os.ReadDir("golang/solutions")
if err != nil {
panic(err)
}
for _, entry := range entries {
if entry.IsDir() {
files, err := os.ReadDir("golang/solutions/" + entry.Name())
if err != nil {
panic(err)
}
for _, file := range files {
if !file.IsDir() {
filesPath = append(filesPath, "golang/solutions/"+entry.Name()+"/"+file.Name())
}
}
}
}
// Prase result from source code
results := make([]Result, 0)
for i := 0; i < len(filesPath); i++ {
Id := string(regexp.MustCompile(`/\d+\.`).Find([]byte(filesPath[i])))
Id = Id[1 : len(Id)-1]
file, err := os.Open(filesPath[i])
if err != nil {
panic(err)
}
defer file.Close()
scanner := bufio.NewScanner(file)
for scanner.Scan() {
text := scanner.Text()
if strings.HasPrefix(text, "Your runtime") {
results = append(results, extractLeetCodeExtensionResult(Id, filesPath[i], scanner))
}
}
}
return results
}
func extractLeetCodeExtensionResult(Id, path string, scanner *bufio.Scanner) Result {
/*
example:
Your runtime beats 96.22 % of golang submissions
Your memory usage beats 48.53 % of golang submissions (4.2 MB)
*/
runtimeBeat := string(regexp.MustCompile(`\d+\.*\d*`).Find(scanner.Bytes()))
runtimeBeatFloat, err := strconv.ParseFloat(runtimeBeat, 64)
if err != nil {
panic(err)
}
if ok := scanner.Scan(); !ok {
panic("missing memory result")
}
memoryUsed := string(regexp.MustCompile(`\d+\.*\d*\s*MB`).Find(scanner.Bytes()))
memoryUsedFloat, err := strconv.ParseFloat(
strings.TrimSpace(memoryUsed[:len(memoryUsed)-2]),
64)
if err != nil {
panic(err)
}
memoryBeat := string(regexp.MustCompile(`\d+\.*\d*`).Find(scanner.Bytes()))
memoryBeatFloat, err := strconv.ParseFloat(memoryBeat, 64)
if err != nil {
panic(err)
}
return Result{
Id: Id,
RuntimeBeat: runtimeBeatFloat,
RuntimeMS: 0,
MemoryBeat: memoryBeatFloat,
MemoryMB: memoryUsedFloat,
Language: "Go",
Path: path,
}
}
|
package database
import (
"context"
"github.com/anshap1719/authentication/models"
"github.com/gofrs/uuid"
"github.com/pkg/errors"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"time"
)
var ErrMergeTokenNotFound = errors.New("No MergeToken found in the database")
var ErrPasswordLoginNotFound = errors.New("No PasswordLogin found in the database")
var ErrResetPasswordNotFound = errors.New("No ResetPassword found in the database")
type ResetPassword struct {
ID uuid.UUID `bson:"id"`
TimeExpires time.Time `bson:"timeExpires"`
UserID string `bson:"userId"`
}
type PasswordLogin struct {
ID primitive.ObjectID `bson:"_id,omitempty"`
Email string `bson:"email"`
Password string `bson:"password"`
Recovery string `bson:"recovery"`
UserID string `bson:"userId"`
}
func GetPasswordLogin(ctx context.Context, Email string) (*PasswordLogin, error) {
var t PasswordLogin
res := models.PasswordLoginCollection.FindOne(ctx, bson.M{"email": Email})
if res.Err() == mongo.ErrNoDocuments {
return nil, ErrPasswordLoginNotFound
} else if res.Err() != nil {
return nil, res.Err()
}
if err := res.Decode(&t); err != nil {
return nil, err
}
return &t, nil
}
func UpdatePasswordLogin(ctx context.Context, updatedPasswordLogin *PasswordLogin) error {
if _, err := models.PasswordLoginCollection.UpdateOne(ctx, bson.M{"email": updatedPasswordLogin.Email}, bson.M{
"$set": updatedPasswordLogin,
}); err == mongo.ErrNoDocuments {
return ErrPasswordLoginNotFound
} else if err != nil {
return err
}
return nil
}
func DeletePasswordLogin(ctx context.Context, Email string) error {
if _, err := models.PasswordLoginCollection.DeleteOne(ctx, bson.M{"email": Email}); err == mongo.ErrNoDocuments {
return ErrPasswordLoginNotFound
} else if err != nil {
return err
}
return nil
}
func QueryPasswordLoginFromID(ctx context.Context, UserID string) (string, error) {
var pl PasswordLogin
res := models.UsersCollection.FindOne(ctx, bson.M{"userId": UserID})
if res.Err() == mongo.ErrNoDocuments {
return "", ErrPasswordLoginNotFound
} else if res.Err() != nil {
return "", res.Err()
}
if err := res.Decode(&pl); err != nil {
return "", err
}
return pl.ID.Hex(), nil
}
func CreateResetPassword(ctx context.Context, newResetPassword *ResetPassword) error {
_, err := models.ResetPasswordCollection.InsertOne(ctx, newResetPassword)
return err
}
func GetResetPassword(ctx context.Context, UserID string) (*ResetPassword, error) {
var rp ResetPassword
res := models.ResetPasswordCollection.FindOne(ctx, bson.M{"userId": UserID})
if res.Err() == mongo.ErrNoDocuments {
return nil, ErrResetPasswordNotFound
} else if res.Err() != nil {
return nil, res.Err()
}
if err := res.Decode(&rp); err != nil {
return nil, err
}
return &rp, nil
}
func DeleteResetPassword(ctx context.Context, UserID string) error {
_, err := models.ResetPasswordCollection.DeleteOne(ctx, bson.M{"userId": UserID})
return err
}
|
package main
import (
"fmt"
)
func main() {
a := 10
fmt.Println("Value of 'a' \t ::", a)
fmt.Printf("Type of 'a' \t :: %T\n", a)
fmt.Println("Address of 'a' \t ::", &a) // '&' gives the address
fmt.Printf("Type of Address of 'a' :: %T\n", &a)
b := &a
fmt.Println("Value of 'b' \t ::", b)
fmt.Printf("Type of 'b' \t :: %T\n", b)
fmt.Println("Value stored at address stored in 'b' ::", *b) // '*' gives the value stored at that address
}
|
package util
// link variable
var (
Version string
DateTime string
)
|
package main
import (
tl "github.com/JoelOtter/termloop"
)
// hudOffset is the number of units that the HUD takes up at the top of the screen
const hudOffset = 2
// BaseLevel is the canvas that all level objects are written to
type BaseLevel struct {
*tl.BaseLevel
Ship *Ship
stageNum int
stage *Stage
}
func newBaseLevel() *BaseLevel {
lvl := &BaseLevel{
BaseLevel: tl.NewBaseLevel(tl.Cell{
Bg: tl.ColorDefault,
Fg: tl.ColorBlack,
Ch: '.',
}),
}
return lvl
}
// Draw will lay out the level onto the screen
func (m *BaseLevel) Draw(screen *tl.Screen) {
// If at stage 0 (not started), or all items have been destroyed, advance to the next stage
levelRunning := false
for _, entity := range m.Entities {
if _, ok := entity.(*BuzzWord); ok {
levelRunning = true
}
}
if !levelRunning {
m.stageNum++
m.SetStage(m.stageNum)
}
m.BaseLevel.Draw(screen)
}
// SetStage will initialize the level to a given stage
func (m *BaseLevel) SetStage(stage int) {
switch stage {
case 1:
m.stage = newStageOne()
case 2:
m.stage = newStageTwo()
default:
gameOver()
}
m.stage.init(m)
}
|
package main
import (
"log"
"net/http"
)
func logout(res http.ResponseWriter, req *http.Request) {
session, err := SessionStore.Get(req, "first_app-session")
if err != nil {
log.Println("error while getting session: ", err.Error())
return
}
session.Values["user_id"] = ""
if err := session.Save(req, res); err != nil {
log.Println("error while saving session: ", err.Error())
return
}
http.Redirect(res, req, "/blogsdetails/1", http.StatusSeeOther)
}
|
package main
import (
"encoding/csv"
"io"
"log"
"strconv"
)
func scanFile(updfile io.Reader) (map[string][]map[int][]string, int, error) {
data := make(map[string][]map[int][]string)
var code int
csvr := csv.NewReader(updfile)
// skip header: first file line
_, err := csvr.Read()
if err != nil {
log.Printf("Error reading header: %v\n", err)
} // .if
// skip header first file line
csvr.Read()
if err != nil {
log.Printf("Error reading header: %v\n", err)
return data, code, err
} // .if
// read lines:
rowNo := 1
for {
line, err := csvr.Read()
if err != nil {
if err == io.EOF { // end of file
break
} // if
log.Printf("Error reading one of the lines: %v\n", err)
return data, code, err
} // .if
row := map[int][]string{rowNo: line}
data[line[1]] = append(data[line[1]], row)
code, _ = strconv.Atoi(line[0])
rowNo++
} // .for
return data, code, nil
} // .scanFile
|
package fullrt
import (
"strconv"
"testing"
"github.com/libp2p/go-libp2p/core/peer"
)
func TestDivideByChunkSize(t *testing.T) {
var keys []peer.ID
for i := 0; i < 10; i++ {
keys = append(keys, peer.ID(strconv.Itoa(i)))
}
convertToStrings := func(peers []peer.ID) []string {
var out []string
for _, p := range peers {
out = append(out, string(p))
}
return out
}
pidsEquals := func(a, b []string) bool {
if len(a) != len(b) {
return false
}
for i, v := range a {
if v != b[i] {
return false
}
}
return true
}
t.Run("Divides", func(t *testing.T) {
gr := divideByChunkSize(keys, 5)
if len(gr) != 2 {
t.Fatal("incorrect number of groups")
}
if g1, expected := convertToStrings(gr[0]), []string{"0", "1", "2", "3", "4"}; !pidsEquals(g1, expected) {
t.Fatalf("expected %v, got %v", expected, g1)
}
if g2, expected := convertToStrings(gr[1]), []string{"5", "6", "7", "8", "9"}; !pidsEquals(g2, expected) {
t.Fatalf("expected %v, got %v", expected, g2)
}
})
t.Run("Remainder", func(t *testing.T) {
gr := divideByChunkSize(keys, 3)
if len(gr) != 4 {
t.Fatal("incorrect number of groups")
}
if g, expected := convertToStrings(gr[0]), []string{"0", "1", "2"}; !pidsEquals(g, expected) {
t.Fatalf("expected %v, got %v", expected, g)
}
if g, expected := convertToStrings(gr[1]), []string{"3", "4", "5"}; !pidsEquals(g, expected) {
t.Fatalf("expected %v, got %v", expected, g)
}
if g, expected := convertToStrings(gr[2]), []string{"6", "7", "8"}; !pidsEquals(g, expected) {
t.Fatalf("expected %v, got %v", expected, g)
}
if g, expected := convertToStrings(gr[3]), []string{"9"}; !pidsEquals(g, expected) {
t.Fatalf("expected %v, got %v", expected, g)
}
})
t.Run("OneEach", func(t *testing.T) {
gr := divideByChunkSize(keys, 1)
if len(gr) != 10 {
t.Fatal("incorrect number of groups")
}
for i := 0; i < 10; i++ {
if g, expected := convertToStrings(gr[i]), []string{strconv.Itoa(i)}; !pidsEquals(g, expected) {
t.Fatalf("expected %v, got %v", expected, g)
}
}
})
t.Run("ChunkSizeLargerThanKeys", func(t *testing.T) {
gr := divideByChunkSize(keys, 11)
if len(gr) != 1 {
t.Fatal("incorrect number of groups")
}
if g, expected := convertToStrings(gr[0]), convertToStrings(keys); !pidsEquals(g, expected) {
t.Fatalf("expected %v, got %v", expected, g)
}
})
}
|
package importer
import (
"fmt"
"strconv"
"sync"
"github.com/DexterLB/mvm/library"
"github.com/DexterLB/mvm/types"
"github.com/DexterLB/osdb"
)
// OsdbClient returns a logged in Osdb client
func (c *Context) OsdbClient() (*osdb.Client, error) {
c.osdbLock.Lock()
defer c.osdbLock.Unlock()
if c.osdbClient != nil {
return c.osdbClient, nil
}
config := &c.Config.Importer.Osdb
client, err := osdb.NewClient()
if err != nil {
return nil, fmt.Errorf("Can't initialize osdb client: %s", err)
}
err = client.LogIn(config.Username, config.Password, "")
if err != nil {
return nil, fmt.Errorf("Can't login to osdb: %s", err)
}
c.osdbClient = client
return client, nil
}
// OsdbIdentifier identifies the video files (matching them to shows) using
// the opensubtitles.org database
func (c *Context) OsdbIdentifier(
files <-chan *library.VideoFile, shows chan<- library.ShowWithFile,
done chan<- *library.VideoFile,
) {
defer close(done)
defer close(shows)
config := &c.Config.Importer.Osdb
client, err := c.OsdbClient()
if err != nil {
c.Errorf("%s", err)
return
}
wg := sync.WaitGroup{}
wg.Add(config.MaxRequests)
for i := 0; i < config.MaxRequests; i++ {
go func() {
c.osdbIdentifierWorker(files, shows, done, client)
wg.Done()
}()
}
wg.Wait()
}
func (c *Context) osdbIdentifierWorker(
files <-chan *library.VideoFile, shows chan<- library.ShowWithFile,
done chan<- *library.VideoFile,
client *osdb.Client,
) {
var currentFiles []*library.VideoFile
maxFiles := c.Config.Importer.Osdb.MaxMoviesPerRequest
for {
select {
case file, ok := <-files:
if !ok {
c.osdbProcessFiles(currentFiles, shows, done, client)
return
}
currentFiles = append(currentFiles, file)
if len(currentFiles) >= maxFiles {
c.osdbProcessFiles(currentFiles, shows, done, client)
currentFiles = currentFiles[0:0]
}
case <-c.Stop:
return
}
}
}
func (c *Context) osdbProcessFiles(
files []*library.VideoFile, shows chan<- library.ShowWithFile,
done chan<- *library.VideoFile,
client *osdb.Client,
) {
if len(files) == 0 {
return
}
hashes := make([]uint64, len(files))
for i := range files {
hashes[i] = uint64(files[i].OsdbHash)
}
movies, err := client.BestMoviesByHashes(hashes)
if err != nil {
for i := range files {
files[i].OsdbError = types.Errorf(
"Opensubtitles.org error: %s", err,
)
done <- files[i]
}
return
}
for i := range movies {
var (
err error
id int
)
if movies[i] == nil {
err = fmt.Errorf("show not found in opensubtitles.org database")
} else {
id, err = strconv.Atoi(movies[i].ID)
if err != nil {
err = fmt.Errorf("can't parse imdb id: %s", err)
}
}
if err != nil {
files[i].OsdbError = types.Errorf(
"can't identify show: %s", err,
)
} else {
show, err := c.Library.GetShowByImdbID(id)
if err != nil {
files[i].OsdbError = types.Errorf(
"Can't find show's imdb ID: %s", err,
)
} else {
// TODO: episode data
show.Files = append(show.Files, files[i])
show.Title = movies[i].Title
show.Year, _ = strconv.Atoi(movies[i].Year) // FIXME: check error
shows <- library.ShowWithFile{
Show: show,
File: files[i],
}
}
}
done <- files[i]
}
}
|
package msgQ
import (
"fmt"
"github.com/garyburd/redigo/redis"
"runtime/debug"
"TskSch/mailer"
)
//INITIALIZER FOR MSG QUEUE
func RedisInit(host string ,port string) redis.Conn {
network := "tcp"
address := host + ":" + port
Conn, err := redis.Dial(network, address)
if err != nil {
fmt.Println("CAN'T CONNECT TO msgQ", err)
mailer.Mail("GOSERVE: Unable to connect to the DB", "Unable to establish connection with the redis database\n\n"+ err.Error()+"\n\nStack Trace: ----- ----------------\n\n\n"+string(debug.Stack()))
return nil
}
return Conn
}
//LENGTH OF MSGQ
func Size(Conn redis.Conn) int {
val, err := redis.Int(Conn.Do("LLEN", "task"))
if err != nil {
fmt.Println("CAN'T POP")
}
return val
}
//POP THE ID
func Pop(Conn redis.Conn) string {
val, err := redis.String(Conn.Do("RPOP", "task"))
if err != nil {
fmt.Println("CAN'T POP")
}
return val
}
//PUSH THE ID IFF UNABLE TO GET ACCESS OF THE COMMAND RESIDING FILE
func Push(Conn redis.Conn, cmd_id string) {
_, err := Conn.Do("RPUSH", "task", cmd_id)
if err != nil {
fmt.Println("CAN'T PUSH IT BACK")
}
}
//PING
func Ping(Conn redis.Conn) error{
_, err := Conn.Do("PING")
return err
}
|
package main
import (
"errors"
"fmt"
"net"
"golangPractice/chat_room/protocol"
"encoding/json"
"encoding/binary"
)
//注册功能
func register(conn net.Conn, userId int, password string) (err error) {
var msg protocol.Message
msg.Cmd = protocol.UserRegister
var registerCmd protocol.RegisterCmd
registerCmd.User.UserId = userId
registerCmd.User.Nick = fmt.Sprintf("stu%d", userId)
registerCmd.User.Sex = "male"
registerCmd.User.Passwd = password
registerCmd.User.Header = fmt.Sprintf("/header/%d.jgp", userId)
data, err := json.Marshal(registerCmd)
if err != nil {
return
}
msg.Data = string(data)
data, err = json.Marshal(msg)
if err != nil {
return
}
//写消息长度
var buf [4]byte
packLen := uint32(len(data))
//将长度值写入切片
binary.BigEndian.PutUint32(buf[:], packLen)
//发送消息长度
n, err := conn.Write(buf[:])
if err != nil || n != 4{
err = errors.New("write header failed")
return
}
_, err = conn.Write([]byte(data))
if err != nil {
return
}
//读取服务端回复
rspMsg, err := readPackage(conn)
if err != nil {
fmt.Println("read package failed, err:", err)
}
fmt.Println(*rspMsg)
return
}
|
package model
import "github.com/jinzhu/gorm"
type Book struct {
gorm.Model
Name string
Cover string
History []*History `gorm:"foreignkey:BookId"`
Page []Page `gorm:"foreignkey:BookId"`
Tags []*Tag `gorm:"many2many:book_tags;"`
Path string
LibraryId uint
}
|
package validation
import (
"testing"
"github.com/stretchr/testify/assert"
"k8s.io/apimachinery/pkg/util/validation/field"
"github.com/openshift/installer/pkg/types/ibmcloud"
)
var (
validRegion = "us-south"
)
func validMinimalPlatform() *ibmcloud.Platform {
return &ibmcloud.Platform{
Region: validRegion,
}
}
func validMachinePool() *ibmcloud.MachinePool {
return &ibmcloud.MachinePool{}
}
func TestValidatePlatform(t *testing.T) {
cases := []struct {
name string
platform *ibmcloud.Platform
valid bool
}{
{
name: "minimal",
platform: validMinimalPlatform(),
valid: true,
},
{
name: "invalid region",
platform: func() *ibmcloud.Platform {
p := validMinimalPlatform()
p.Region = "invalid"
return p
}(),
valid: false,
},
{
name: "missing region",
platform: func() *ibmcloud.Platform {
p := validMinimalPlatform()
p.Region = ""
return p
}(),
valid: false,
},
{
name: "valid machine pool",
platform: func() *ibmcloud.Platform {
p := validMinimalPlatform()
p.DefaultMachinePlatform = validMachinePool()
return p
}(),
valid: true,
},
{
name: "valid vpc and subnets",
platform: func() *ibmcloud.Platform {
p := validMinimalPlatform()
p.VPCName = "valid-vpc-subnets"
p.ControlPlaneSubnets = []string{"cp-1", "cp-2", "cp-3"}
p.ComputeSubnets = []string{"comp-1", "comp-2"}
return p
}(),
valid: true,
},
{
name: "vpc without control plane subnet",
platform: func() *ibmcloud.Platform {
p := validMinimalPlatform()
p.VPCName = "missing-cp-subnet"
p.ComputeSubnets = []string{"comp-1", "comp-2"}
return p
}(),
valid: false,
},
{
name: "vpc without compute subnet",
platform: func() *ibmcloud.Platform {
p := validMinimalPlatform()
p.VPCName = "missing-comp-subnet"
p.ControlPlaneSubnets = []string{"cp-1", "cp-2"}
return p
}(),
valid: false,
},
{
name: "subnets without vpc",
platform: func() *ibmcloud.Platform {
p := validMinimalPlatform()
p.ControlPlaneSubnets = []string{"cp-1"}
p.ComputeSubnets = []string{"comp-1"}
return p
}(),
valid: false,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
err := ValidatePlatform(tc.platform, field.NewPath("test-path")).ToAggregate()
if tc.valid {
assert.NoError(t, err)
} else {
assert.Error(t, err)
}
})
}
}
|
package rigis
import (
"net/http"
"github.com/rocinax/rigis/pkg/rule"
)
type node struct {
rule rule.Rule
filter filter
balanceType string
backendHosts []backendHost
backendHostWeightIndex int
backendHostIndex int
}
func newNode(
nrule rule.Rule,
nfilter filter,
balanceType string,
backendHosts []backendHost,
) node {
return node{
rule: nrule,
filter: nfilter,
balanceType: balanceType,
backendHosts: backendHosts,
backendHostWeightIndex: 0,
backendHostIndex: 0,
}
}
func (n node) serveHTTP(rw http.ResponseWriter, req *http.Request) {
backend := n.getBackendHost()
backend.serveHTTP(rw, req)
}
func (n node) executeRule(req *http.Request) bool {
return n.rule.Execute(req)
}
func (n node) executeFilter(req *http.Request) bool {
return n.filter.Execute(req)
}
func (n node) getBackendHost() *backendHost {
resultHost := n.backendHosts[n.backendHostIndex]
n.backendHostWeightIndex++
if n.backendHostWeightIndex >= n.backendHosts[n.backendHostIndex].weight {
n.nextBackendHost()
}
return &resultHost
}
func (n node) nextBackendHost() {
n.backendHostWeightIndex = 0
n.backendHostIndex++
if n.backendHostIndex >= len(n.backendHosts) {
n.backendHostIndex = 0
}
}
func (n node) getNextBackendHost() *backendHost {
n.nextBackendHost()
return n.getBackendHost()
}
|
package cmd
type devTestCase struct{}
/*func TestDev(t *testing.T) {
dir, err := ioutil.TempDir("", "test")
if err != nil {
t.Fatalf("Error creating temporary directory: %v", err)
}
dir, err = filepath.EvalSymlinks(dir)
if err != nil {
t.Fatal(err)
}
wdBackup, err := os.Getwd()
if err != nil {
t.Fatalf("Error getting current working directory: %v", err)
}
err = os.Chdir(dir)
if err != nil {
t.Fatalf("Error changing working directory: %v", err)
}
defer func() {
//Delete temp folder
err = os.Chdir(wdBackup)
if err != nil {
t.Fatalf("Error changing dir back: %v", err)
}
err = os.RemoveAll(dir)
if err != nil {
t.Fatalf("Error removing dir: %v", err)
}
}()
testCases := []devTestCase{
devTestCase{
name: "Invalid flags",
fakeConfig: &latest.Config{},
skipBuildFlag: true,
forceBuildFlag: true,
expectedErr: "Flags --skip-build & --force-build cannot be used together",
},
/*devTestCase{
name: "interactive without images",
fakeConfig: &latest.Config{},
fakeKubeClient: &kubectl.Client{
Client: fake.NewSimpleClientset(),
CurrentContext: "minikube",
},
files: map[string]interface{}{
constants.DefaultConfigPath: &latest.Config{
Version: latest.Version,
},
},
interactiveFlag: true,
expectedErr: "Your configuration does not contain any images to build for interactive mode. If you simply want to start the terminal instead of streaming the logs, run `devspace dev -t`",
},
devTestCase{
name: "Cloud Space can't be resumed",
fakeConfig: &latest.Config{},
fakeKubeClient: &kubectl.Client{
Client: fake.NewSimpleClientset(),
CurrentContext: "minikube",
},
files: map[string]interface{}{
constants.DefaultConfigPath: &latest.Config{
Version: latest.Version,
Dev: &latest.DevConfig{
Interactive: &latest.InteractiveConfig{},
},
},
},
expectedErr: "is cloud space: Unable to get AuthInfo for kube-context: Unable to find kube-context 'minikube' in kube-config file",
},*/ /*
}
log.OverrideRuntimeErrorHandler(true)
log.SetInstance(&log.DiscardLogger{PanicOnExit: true})
for _, testCase := range testCases {
testDev(t, testCase)
}
}
func testDev(t *testing.T, testCase devTestCase) {
defer func() {
for path := range testCase.files {
removeTask := strings.Split(path, "/")[0]
err := os.RemoveAll(removeTask)
assert.NilError(t, err, "Error cleaning up folder in testCase %s", testCase.name)
}
err := os.RemoveAll(log.Logdir)
assert.NilError(t, err, "Error cleaning up folder in testCase %s", testCase.name)
}()
cloudpkg.DefaultGraphqlClient = &customGraphqlClient{
responses: testCase.graphQLResponses,
}
providerConfig, err := cloudconfig.Load()
assert.NilError(t, err, "Error getting provider config in testCase %s", testCase.name)
providerConfig.Providers = testCase.providerList
loader.SetFakeConfig(testCase.fakeConfig)
loader.ResetConfig()
generated.ResetConfig()
kubeconfig.SetFakeConfig(testCase.fakeKubeConfig)
kubectl.SetFakeClient(testCase.fakeKubeClient)
for path, content := range testCase.files {
asYAML, err := yaml.Marshal(content)
assert.NilError(t, err, "Error parsing config to yaml in testCase %s", testCase.name)
err = fsutil.WriteToFile(asYAML, path)
assert.NilError(t, err, "Error writing file in testCase %s", testCase.name)
}
err = (&DevCmd{
GlobalFlags: &testCase.globalFlags,
AllowCyclicDependencies: testCase.allowCyclicDependenciesFlag,
SkipPush: testCase.skipPushFlag,
ForceBuild: testCase.forceBuildFlag,
SkipBuild: testCase.skipBuildFlag,
BuildSequential: testCase.buildSequentialFlag,
ForceDeploy: testCase.forceDeploymentFlag,
Deployments: testCase.deploymentsFlag,
ForceDependencies: testCase.forceDependenciesFlag,
Sync: testCase.syncFlag,
Terminal: testCase.terminalFlag,
ExitAfterDeploy: testCase.exitAfterDeployFlag,
SkipPipeline: testCase.skipPipelineFlag,
Portforwarding: testCase.portForwardingFlag,
VerboseSync: testCase.verboseSyncFlag,
Interactive: testCase.interactiveFlag,
}).Run(nil, []string{})
if testCase.expectedErr == "" {
assert.NilError(t, err, "Unexpected error in testCase %s.", testCase.name)
} else {
assert.Error(t, err, testCase.expectedErr, "Wrong or no error in testCase %s.", testCase.name)
}
}*/
|
/*
Copyright 2021 CodeNotary, Inc. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package auth
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc"
)
func TestTokenAuth(t *testing.T) {
token := TokenAuth{
Token: "123456",
}
m, err := token.GetRequestMetadata(context.Background(), "")
if err != nil {
t.Errorf("Error GetRequestMetadata %s", err)
}
header, ok := m["authorization"]
if !ok {
t.Errorf("Error GetRequestMetadata expected authorization header is missing")
}
if header != "Bearer "+token.Token {
t.Errorf("Error GetRequestMetadata wrong authorization header")
}
if token.RequireTransportSecurity() {
t.Errorf("Error RequireTransportSecurity expected to return false")
}
}
func TestClientUnaryInterceptor(t *testing.T) {
f := ClientUnaryInterceptor("token")
invoker := func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, opts ...grpc.CallOption) error {
return nil
}
err := f(context.Background(), "", "", "", nil, invoker)
assert.Nil(t, err)
}
func TestClientStreamInterceptor(t *testing.T) {
f := ClientStreamInterceptor("token")
streamer := func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, opts ...grpc.CallOption) (grpc.ClientStream, error) {
return nil, nil
}
_, err := f(context.Background(), nil, nil, "", streamer)
assert.Nil(t, err)
}
|
package endpoint
import (
"context"
"github.com/go-kit/kit/endpoint"
"github.com/l-vitaly/golang-test-task/pkg/crawl"
"github.com/l-vitaly/golang-test-task/pkg/service"
)
// Set collects all of the endpoints that compose an crawl service.
type Set struct {
PostURLsEndpoint endpoint.Endpoint
}
// New returns a Endpoints.
func New(svc service.Service) Set {
var postURLsEndpoint endpoint.Endpoint
{
postURLsEndpoint = makePostURLsEndpoint(svc)
}
return Set{
PostURLsEndpoint: postURLsEndpoint,
}
}
func makePostURLsEndpoint(s service.Service) endpoint.Endpoint {
return func(_ context.Context, request interface{}) (interface{}, error) {
results, err := s.PostURLs(request.([]string))
return PostURLsResponse{Data: results, Err: err}, nil
}
}
// PostURLsResponse collects the request parameters for the PostURLs method.
type PostURLsResponse struct {
Data []crawl.Result `json:"data"`
Err error `json:"error,omitempty"`
}
// Failed implements Failer.
func (r PostURLsResponse) Failed() error {
return r.Err
}
|
package main
import (
"bot"
"log"
)
func main() {
log.Println("Start bot")
config, err := bot.ReadConfigFromEnv()
if err != nil {
log.Fatal(err)
}
err = bot.RunBot(config)
if err != nil {
log.Fatal(err)
}
log.Println("Stop bot")
}
|
package util
import "math"
type Vec2 struct {
X float64
Y float64
}
func (v1 *Vec2) ToInts() (X, Y int) {
return int(v1.X), int(v1.Y)
}
func (v1 *Vec2) ToVals() (X, Y float64) {
return v1.X, v1.Y
}
func (v1 *Vec2) Add(v2 *Vec2) *Vec2 {
return &Vec2{v1.X + v2.X, v1.Y + v2.Y}
}
func (v1 *Vec2) Sub(v2 *Vec2) *Vec2 {
return &Vec2{v1.X - v2.X, v1.Y - v2.Y}
}
func (v1 *Vec2) Dist(v2 *Vec2) float64 {
return math.Sqrt(math.Pow(v1.Sub(v2).X, 2) + math.Pow(v1.Sub(v2).Y, 2))
}
func (v1 *Vec2) Dist2(v2 *Vec2) float64 {
return (math.Pow(v1.Sub(v2).X, 2) + math.Pow(v1.Sub(v2).Y, 2))
}
func (v1 *Vec2) Norm(v2 *Vec2) *Vec2 {
return v2.Sub(v1).Div(v1.Dist(v2))
}
func (v1 *Vec2) Norm2(v2 *Vec2) *Vec2 {
return v2.Sub(v1).Div(v1.Dist2(v2))
}
func (v1 *Vec2) Div(val float64) *Vec2 {
return &Vec2{X: v1.X / val, Y: v1.Y / val}
}
func (v1 *Vec2) Mul(val float64) *Vec2 {
return &Vec2{X: v1.X * val, Y: v1.Y * val}
}
type Vec3 struct {
X float64
Y float64
Z float64
}
func (v1 Vec3) ToInts() (X, Y, Z int) {
return int(v1.X), int(v1.Y), int(v1.Z)
}
func (v1 Vec3) ToVals() (X, Y, Z float64) {
return v1.X, v1.Y, v1.Z
}
func (v1 Vec3) Add(v2 Vec3) *Vec3 {
return &Vec3{v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z}
}
|
package pgsql
import (
"testing"
)
func TestInt4Range(t *testing.T) {
testlist2{{
valuer: Int4RangeFromIntArray2,
scanner: Int4RangeToIntArray2,
data: []testdata{
{
input: [2]int{-2147483648, 2147483647},
output: [2]int{-2147483648, 2147483647}},
},
}, {
valuer: Int4RangeFromInt8Array2,
scanner: Int4RangeToInt8Array2,
data: []testdata{
{
input: [2]int8{-128, 127},
output: [2]int8{-128, 127}},
},
}, {
valuer: Int4RangeFromInt16Array2,
scanner: Int4RangeToInt16Array2,
data: []testdata{
{
input: [2]int16{-32768, 32767},
output: [2]int16{-32768, 32767}},
},
}, {
valuer: Int4RangeFromInt32Array2,
scanner: Int4RangeToInt32Array2,
data: []testdata{
{
input: [2]int32{-2147483648, 2147483647},
output: [2]int32{-2147483648, 2147483647}},
},
}, {
valuer: Int4RangeFromInt64Array2,
scanner: Int4RangeToInt64Array2,
data: []testdata{
{
input: [2]int64{-2147483648, 2147483647},
output: [2]int64{-2147483648, 2147483647}},
},
}, {
valuer: Int4RangeFromUintArray2,
scanner: Int4RangeToUintArray2,
data: []testdata{
{
input: [2]uint{0, 2147483647},
output: [2]uint{0, 2147483647}},
},
}, {
valuer: Int4RangeFromUint8Array2,
scanner: Int4RangeToUint8Array2,
data: []testdata{
{
input: [2]uint8{0, 255},
output: [2]uint8{0, 255}},
},
}, {
valuer: Int4RangeFromUint16Array2,
scanner: Int4RangeToUint16Array2,
data: []testdata{
{
input: [2]uint16{0, 65535},
output: [2]uint16{0, 65535}},
},
}, {
valuer: Int4RangeFromUint32Array2,
scanner: Int4RangeToUint32Array2,
data: []testdata{
{
input: [2]uint32{0, 2147483647},
output: [2]uint32{0, 2147483647}},
},
}, {
valuer: Int4RangeFromUint64Array2,
scanner: Int4RangeToUint64Array2,
data: []testdata{
{
input: [2]uint64{0, 2147483647},
output: [2]uint64{0, 2147483647}},
},
}, {
valuer: Int4RangeFromFloat32Array2,
scanner: Int4RangeToFloat32Array2,
data: []testdata{
{
input: [2]float32{-2147483648.0, 214748364.0},
output: [2]float32{-2147483648.0, 214748364.0}},
},
}, {
valuer: Int4RangeFromFloat64Array2,
scanner: Int4RangeToFloat64Array2,
data: []testdata{
{
input: [2]float64{-2147483648.0, 2147483647.0},
output: [2]float64{-2147483648.0, 2147483647.0}},
},
}, {
data: []testdata{
{
input: string("[-2147483648,2147483647)"),
output: string(`[-2147483648,2147483647)`)},
},
}, {
data: []testdata{
{
input: []byte("[-2147483648,2147483647)"),
output: []byte(`[-2147483648,2147483647)`)},
},
}}.execute(t, "int4range")
}
|
package models
import (
"database/sql/driver"
"encoding/json"
"errors"
)
type StringMap map[string]string
func (s StringMap) Value() (driver.Value, error) {
j, err := json.Marshal(s)
return j, err
}
func (s *StringMap) Scan(src interface{}) error {
source, ok := src.([]byte)
if !ok {
return errors.New("type assertion .([]byte) failed")
}
i := make(StringMap)
err := json.Unmarshal(source, &i)
if err != nil {
return err
}
*s = i
return nil
}
|
package httpclient
import (
"fmt"
"io/ioutil"
"net/http"
"github.com/go-chi/render"
)
func DoRequest(httpClient *http.Client, req *http.Request, resultTemplate interface{}) error {
res, err := httpClient.Do(req)
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode < 200 || res.StatusCode >= 300 {
bodyBytes, err := ioutil.ReadAll(res.Body)
if err != nil {
return fmt.Errorf("Cannot read %d error response", res.StatusCode)
}
return fmt.Errorf("Status: %d, Error body: %s", res.StatusCode, bodyBytes)
}
if err := render.DecodeJSON(res.Body, &resultTemplate); err != nil {
return fmt.Errorf("Couldn't decode message %w", err)
}
return nil
}
|
package controller
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"strconv"
"github.com/GoGroup/Movie-and-events/model"
)
const base = "https://api.themoviedb.org/3/movie/"
const upcomingQuery = "upcoming?"
const apiKey = "f4b8e415cb9ab402e5c1d72176cab35b"
//const videoBase = "http://api.themoviedb.org/3/movie/157336/videos?api_key=###"
const videoQuery = "/videos?"
func GetMovieDetails(id int) (*model.MovieDetails, error, error) {
res, err := http.Get(base + strconv.Itoa(id) + "?api_key=" + apiKey)
if err != nil {
panic(err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
panic(err.Error())
}
var details = new(model.MovieDetails)
err2 := json.Unmarshal([]byte(body), &details)
if err2 != nil {
fmt.Println("whoops:", err2)
}
return details, err, err2
}
func GetUpcomingMovies() (*model.UpcomingMovies, error, error) {
res, err := http.Get(base + upcomingQuery + "api_key=" + apiKey)
if err != nil {
panic(err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
panic(err.Error())
}
errr := ioutil.WriteFile("WriteFile.json", body, 0644)
if errr != nil {
fmt.Println("something went wrong")
}
var upcoming = new(model.UpcomingMovies)
err2 := json.Unmarshal([]byte(body), &upcoming)
if err2 != nil {
fmt.Println("whoops:", err2)
}
return upcoming, err, err2
}
func GetTrailer(i string) string {
res, err := http.Get(base + i + videoQuery + "api_key=" + apiKey)
if err != nil {
panic(err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
panic(err.Error())
}
var vid = new(model.VideoLists)
err2 := json.Unmarshal([]byte(body), &vid)
//m.Trailer=vid.VList[0].Key
if err2 != nil {
fmt.Println("whoops:", err2)
}
return vid.VList[0].Key
}
//const path = "/pjeMs3yqRmFL3giJy4PMXWZTTPa.jpg"
// func getUpcomingMovies(body []byte) (*UpcomingMovies, error) {
// var upcoming = new(UpcomingMovies)
// err := json.Unmarshal(body, &upcoming)
// if err != nil {
// fmt.Println("whoops:", err)
// }
// return upcoming, err
// }
// func upcoming_handler(w http.ResponseWriter, r *http.Request) {
// res, err := http.Get(b + "api_key=" + apiKey)
// if err != nil {
// panic(err.Error())
// }
// body, err := ioutil.ReadAll(res.Body)
// if err != nil {
// panic(err.Error())
// }
// s, err := getUpcomingMovies([]byte(body))
// fmt.Println(s)
// temp.ExecuteTemplate(w, "display.html", s)
// }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.