How to enable an OpenGL Texture for different multiple buffer objects?

I have a problem about activating a single texture to multiple buffer objects. I am trying to draw two different graphical objects that using the same texture. However could not make it bind.

After searchs so far, I could find an answer that fits to my question in this (Re-using one texture for multiple OpenGL Quads) link. I tried this method in my code by using the glBindTexture() function before the main opengl render loop, and also inside of the render loop but it did not bind. Also it is said that, bind the texture before the draw call, in here (OpenGl all models are with the same texture). But this way also did not work for me.

How can I use the exact same texture which is named texture1 for second buffer object?

I use two buffer objects and two vertex array objects for different graphical objects. What I really want to accomplish to describe only one texture after the first buffer array and then use the exact same texture for the second object. But when I try to bind the texture after vertex array object it does not work.

By the way I do not load any images for the texture. The main purpose that I use texture in order to utilize the texture coordinates. I do necessary works in the fragment shader.

#shader vertex
#version 330 core

layout (location=0) in vec3 position;
layout (location=1) in vec2 TextureCoords;

out vec2 TexCoord;
void main()
{   
  TexCoord = vec2(TextureCoords.x, TextureCoords.y);
  gl_Position = vec4(position, 1.0);
};


#shader fragment
#version 330 core

out vec4 fragColor;
in vec2 TexCoord;

void main()
{
  vec2 xy = TexCoord.xy;
  vec4 color = vec4(vec3(xy.x), 1.0);
  fragColor = color;
};

float vertexArray1[] = {
 //      Vertex Position | Texture Coords
 //       x     y     z     x      y
         0.9f, 0.9f, 0.0f, 1.0f, 1.0f,
         0.9f, 0.2f, 0.0f, 1.0f, 0.0f,
         0.2f, 0.2f, 0.0f, 0.0f, 0.0f,

         0.2f, 0.9f, 0.0f, 0.0f, 1.0f,
         0.9f, 0.9f, 0.0f, 1.0f, 1.0f,
         0.2f, 0.2f, 0.0f, 0.0f, 0.0f,
    };

float vertexArray2[] = {

        -0.2f, 0.9f, 0.0f, 1.0f, 1.0f,
        -0.2f, 0.2f, 0.0f, 1.0f, 0.0f,
        -0.9f, 0.2f, 0.0f, 0.0f, 0.0f,

        -0.9f, 0.9f, 0.0f, 0.0f, 1.0f,
        -0.2f, 0.9f, 0.0f, 1.0f, 1.0f,
        -0.9f, 0.2f, 0.0f, 0.0f, 0.0f,
 };


unsigned int buffer;
unsigned int VAO;

glGenBuffers(1, &buffer);
glGenVertexArrays(1, &VAO);

glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertexArray1), vertexArray1, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, 0);
glEnableVertexAttribArray(0);

unsigned int texture1;
glGenTextures(1, &texture1);
glBindTexture(GL_TEXTURE_2D, texture1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(1);

unsigned int buffer2;
unsigned int VAO2;
glGenBuffers(1, &buffer2);
glGenVertexArrays(1, &VAO2);

glBindVertexArray(VAO2);
glBindBuffer(GL_ARRAY_BUFFER, buffer2);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertexArray2), vertexArray2, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, 0);
glEnableVertexAttribArray(0);

// I want to use the previously described texture1 in here, but it does not bind.
glBindTexture(GL_TEXTURE_2D, texture1); 

while(!glfwWindowShouldClose(window)){

    processInput(window);
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(shader);
    glBindVertexArray(VAO);
    glDrawArrays(GL_LINES, 0, 6*3*1);

    glBindVertexArray(VAO2);
    glDrawArrays(GL_LINES, 0, 6*3*1);

    glfwSwapBuffers(window);
    glfwPollEvents();
}

Note: When I create another different texture for the buffer2 object it works like a charm. I mean texture1 for buffer1, texture2 for buffer2... But I want to keep the number of the texture as possible as minimum. Maybe in future developments, I will have to create more than 50 buffer object, thus I do not want to create different textures for every single buffer object.

EDIT: I have changed my misunderstanding of "binding a texture to a vertex array" to "enabling attributes of a texture for other objects". I've also included my shader scripts for debugging purposes.